zen 0.2.8 → 0.3b

data/lib/zen/controller/base_controller.rb

@@ -3,17 +3,21 @@ module Zen
   #:nodoc:
   module Controller
     ##
-    # The BaseController is extended by both the FrontendController and the 
-    # BackendController. This controller is mostly used to set and retrieve 
+    # 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
-      include ::Zen::Language
+      helper :user, :csrf, :message, :cgi, :locale, :controller,
+        :blue_form, :paginate, :stacked_aspect
 
-      helper :csrf, :cgi
+      # Configure the pagination helper
+      trait :paginate => {
+        :limit => 20,
+        :var   => 'page'
+      }
     end # BaseController
   end # Controller
 end # Zen

data/lib/zen/controller/frontend_controller.rb

@@ -7,7 +7,6 @@ module Zen
     # 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::Controller::BaseController

data/lib/zen/controller/main_controller.rb

@@ -1,65 +1,53 @@
-#:nodoc:
 module Zen
-  #:nodoc:
   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 from the settings table.
+    # The MainController controller is used to load the correct template files
+    # based on the current URI.
     #
-    # @author Yorick Peterse
     # @since  0.1
     #
     class MainController < Zen::Controller::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.
+      # Determines what template group and template have to be rendered based on
+      # the requested URI. If the template does not exist a 404 template
+      # (404.xhtml) will be rendered. If that template doesn't exist either a
+      # plain text message will be displayed.
       #
-      # @author Yorick Peterse
       # @since  0.1
-      # @param  [Array] uri Array containing all arguments (thus the URI).
+      # @param  [Array] uri Array containing all the URI segments that were
+      #  specified (without any file extensions).
       #
       def index(*uri)
-        @request_uri = []
-        theme        = plugin(:settings, :get, :theme).value
-        
-        # Clean the URI of nasty input
-        uri.each { |v| @request_uri.push(h(v)) }
-        
+        @request_uri = uri.map { |v| h(v) }
+        theme        = get_setting(:theme).value
+
+        if theme.nil? or theme.empty?
+          respond(lang('zen_general.errors.no_theme'))
+        end
+
+        theme = Zen::Theme[theme]
+
         if !@request_uri[0] or @request_uri[0].empty?
-          section         = plugin(:settings, :get, :default_section).value
-          section         = ::Sections::Model::Section[section].slug
-          @request_uri[0] = section
+          @request_uri[0] = theme.default_template_group
         end
-        
+
         if !@request_uri[1] or @request_uri[1].empty?
           @request_uri[1] = 'index'
         end
-        
-        # A theme is always required
-        if theme.nil? or theme.empty?
-          respond(lang('zen_general.errors.no_theme'))
-        end
 
-        theme    = ::Zen::Theme[theme]
-        group    = @request_uri[0]
-        template = @request_uri[1]
-        
-        # Create the group, template and partial paths
-        theme_path    = theme.template_dir
-        group_path    = File.join(theme_path, group)
-        template_path = File.join(theme_path, group, "#{template}.xhtml")
-        
-        # Check if the group exists
-        if File.directory?(group_path) and File.exists?(template_path)
-          render_file(template_path)
+        path  = File.join(
+          theme.templates,
+          @request_uri[0],
+          "#{@request_uri[1]}.xhtml"
+        )
+
+        if File.exist?(path)
+          render_file(path)
         else
-          not_found = File.join(theme_path, '404.xhtml')
-          
+          not_found = File.join(theme.templates, '404.xhtml')
+
           if File.exist?(not_found)
             respond(render_file(not_found), 404)
           else

data/lib/zen/controller/preview.rb

@@ -3,11 +3,11 @@ module Zen
   #:nodoc
   module Controller
     ##
-    # Controller that can be used to render a block of markup based on the POST 
-    # data. This controller is useful for generating previews when using the 
+    # Controller that can be used to render a block of markup based on the POST
+    # data. This controller is useful for generating previews when using the
     # text editor for example.
     #
-    # In order to render a preview you'll have to send a POST request with the 
+    # In order to render a preview you'll have to send a POST request with the
     # following data in it:
     #
     # * engine: The markup engine to use (Markdown, Textile, etc).
@@ -19,11 +19,10 @@ module Zen
     #     engine: "markdown"
     #     markup: "Hello **world**!"
     #
-    # The return data is an HTTP status code and the HTML as the body. The HTTP 
-    # status code will be 200 whenever the data was converted and or 400 in case 
+    # The return data is an HTTP status code and the HTML as the body. The HTTP
+    # status code will be 200 whenever the data was converted and or 400 in case
     # of an error (e.g. an incorrect markup engine was specified).
     #
-    # @author Yorick Peterse
     # @since  0.2.6
     #
     class Preview < Zen::Controller::AdminController
@@ -32,7 +31,6 @@ module Zen
       ##
       # Converts the markup set in the POST data and returns the HTML.
       #
-      # @author Yorick Peterse
       # @since  0.2.6
       #
       def index
@@ -42,7 +40,10 @@ module Zen
 
         begin
           respond(
-            plugin(:markup, request.params['engine'], request.params['markup']), 
+            Zen::Markup.convert(
+              request.params['engine'],
+              request.params['markup']
+            ),
             200
           )
         rescue

data/lib/zen/controller/translations.rb

@@ -0,0 +1,49 @@
+module Zen
+  module Controller
+    ##
+    # Controller that generates a Javascript variable containing various
+    # language strings that should be available in Javascript code.
+    #
+    # @since  0.3
+    #
+    class Translations < Zen::Controller::FrontendController
+      map '/admin/js/zen/lib/translations.js'
+
+      # Array containing all the translations to copy.
+      TRANSLATIONS = [
+        'zen_general.buttons.bold',
+        'zen_general.buttons.italic',
+        'zen_general.buttons.link',
+        'zen_general.buttons.ul',
+        'zen_general.buttons.ol',
+        'zen_general.buttons.preview',
+        'zen_general.buttons.close',
+        'zen_general.datepicker.select_a_time',
+        'zen_general.datepicker.use_mouse_wheel',
+        'zen_general.datepicker.time_confirm_button',
+        'zen_general.datepicker.apply_range',
+        'zen_general.datepicker.cancel',
+        'zen_general.datepicker.week'
+      ]
+
+      ##
+      # Renders the translations as a Javascript variable. It is a bit of a
+      # dirty process but it means I don't have to use the JSON gem which can
+      # suck up quite a bit of memory over time.
+      #
+      # @since 0.3
+      #
+      def index
+        var = 'var Zen = Zen || {}; Zen.translations = {'
+
+        TRANSLATIONS.each do |k|
+          var += "'#{k}': '#{lang(k)}',"
+        end
+
+        var += '};'
+
+        respond(var, 200, 'Content-Type' => 'text/javascript')
+      end
+    end # Language
+  end # Controller
+end # Zen

data/lib/zen/error.rb

@@ -0,0 +1,17 @@
+#:nodoc:
+module Zen
+  # Error class used by Zen::Language.
+  class LanguageError < StandardError; end
+
+  # Error class used by Zen::Package.
+  class PackageError < StandardError; end
+
+  # Error class used by Zen::Plugin.
+  class PluginError < StandardError; end
+
+  # Error class used by Zen::Theme.
+  class ThemeError < StandardError; end
+
+  # Error class used by Zen::Validation.
+  class ValidationError < StandardError; end
+end # Zen

data/lib/zen/event.rb

@@ -0,0 +1,118 @@
+module Zen
+  ##
+  # Zen::Event is a module that can be used to register and execute events.
+  # Events are small Procs that are executed before or after something has
+  # happened. Events can be useful when you want to send an Email after a
+  # certain record has been added without having to monkey patch a particular
+  # model (which would overwrite any existing events). Events can also be used
+  # to modify data at certain points in your application. For example, you might
+  # have an event that changes a comment's status before inserting it into the
+  # database.
+  #
+  # Adding a event can be done by calling Zen::Event.listen as following:
+  #
+  #     Zen::Event.listen(:event_name) do
+  #
+  #     end
+  #
+  # The block that's added to the Zen::Event.listen() takes any number of
+  # parameters depending on the ones passed to Zen::Event.call(). For example,
+  # if the event is called and passed two parameters both parameters will be
+  # passed to the event's block.
+  #
+  # Events are called in sequence and each event will receive the same
+  # parameters (given they take the same parameters). This means that if you
+  # have 5 events each event could potentially receive different data depending
+  # on whether a previous event modified the data. This is illustrated in the
+  # following example:
+  #
+  #     obj = Struct.new(:name).new('Python')
+  #
+  #     Zen::Event.listen(:event_1) do |obj|
+  #       obj.name = 'Ruby'
+  #     end
+  #
+  #     Zen::Event.listen(:event_1) do |obj|
+  #       obj.name = 'Perl'
+  #     end
+  #
+  #     Zen::Event.call(:event_1, obj)
+  #
+  #     puts obj.name # => "Perl"
+  #
+  # @example Prints "Hello Ruby" 10 times
+  #  Zen::Event.listen(:greet) do |amount, name|
+  #    amount.times do
+  #      puts "Hello #{name}"
+  #    end
+  #  end
+  #
+  #  Zen::Event.call(:greet, 10, 'Ruby')
+  #
+  # @since  0.3
+  #
+  module Event
+    # Hash containing all the event names and a list of procs to execute for all
+    # those events.
+    REGISTERED = {}
+
+    class << self
+      ##
+      # Runs all the events for the name and passes the arguments to each event.
+      # Each event is run in it's own thread and is wrapped in a mutex.
+      #
+      # @example
+      #  Zen::Event.call(:new_user, User[1])
+      #
+      # @since  0.3
+      # @param  [#to_sym] event The name of the event to invoke.
+      # @param  [Array] *args An array of arguments to pass to each event.
+      #
+      def call(event, *args)
+        event = event.to_sym
+
+        if REGISTERED.key?(event)
+          REGISTERED[event].each do |event|
+            event.call(*args)
+          end
+        end
+      end
+
+      ##
+      # Adds a new event to the list of events for the given name. If the event
+      # does not exist it will be created automatically.
+      #
+      # @example
+      #  Zen::Event.listen(:new_user) do |user|
+      #    puts user.name
+      #  end
+      #
+      # @since  0.3
+      # @param  [#to_sym] event The name of the event.
+      # @param  [Proc] block A block to execute when the event is invoked.
+      #
+      def listen(event, &block)
+        event               = event.to_sym
+        REGISTERED[event] ||= []
+
+        REGISTERED[event].push(block)
+      end
+
+      ##
+      # Removes all events for the given names.
+      #
+      # @example
+      #  Zen::Event.delete(:before_new_user, :after_new_user)
+      #
+      # @since  0.3
+      # @param  [Array] *names The names of the events to remove. Each name
+      #  should be a symbol or something that responds to #to_sym().
+      #
+      def delete(*names)
+        names.each do |name|
+          REGISTERED.delete(name.to_sym)
+        end
+      end
+    end # class << self
+  end # Event
+end # Zen

data/lib/zen/helper/asset.rb

@@ -0,0 +1,63 @@
+module Ramaze
+  module Helper
+    ##
+    # Helper that makes it a bit easier to add assets to Zen.asset. All assets
+    # added via this module are *only* loaded for the class that called the
+    # method.
+    #
+    # @since  0.3
+    #
+    module Asset
+      ##
+      # Extends the including class with the ClassMethods module.
+      #
+      # @since  0.3
+      # @param  [Class] klass The klass that included this module.
+      #
+      def self.included(klass)
+        klass.extend(Ramaze::Helper::Asset::ClassMethods)
+      end
+
+      ##
+      # Module of which the methods will become available as class methods to
+      # the class that included Ramaze::Helper::Asset.
+      #
+      # @since  0.3
+      #
+      module ClassMethods
+        ##
+        # Provides a shortcut method to Zen.asset.serve() and automatically
+        # loads all the given assets for the calling class.
+        #
+        # @since  0.3
+        # @see    Ramaze::Asset::Environment#serve()
+        #
+        def serve(type, files, options = {})
+          Zen.asset.serve(type, files, options.merge({:controller => self}))
+        end
+
+        ##
+        # Loads an asset group. This method can either load a single asset group
+        # or an array of groups.
+        #
+        # @example
+        #  load_asset_group(:datepicker)
+        #  load_asset_group([:editor, :datepicker])
+        #
+        # @since  0.3
+        # @see    Ramaze::Asset::Environment#load_asset_group()
+        # @param  [Array] methods An array of methods to load the assets for.
+        #
+        def load_asset_group(name, methods = nil)
+          if name.respond_to?(:each)
+            name.each do |n|
+              Zen.asset.load_asset_group(n, self, methods)
+            end
+          else
+            Zen.asset.load_asset_group(name, self, methods)
+          end
+        end
+      end # ClassMethods
+    end # Asset
+  end # Helper
+end # Ramaze

data/lib/zen/helper/breadcrumb.rb

@@ -18,7 +18,6 @@ module Ramaze
     # 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
@@ -33,7 +32,6 @@ module Ramaze
       # 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
       #
@@ -51,9 +49,8 @@ module Ramaze
       # @example
       #  get_breadcrumbs ">" # => "Articles > Edit"
       #
-      # @author Yorick Peterse
       # @param  [String] separator The HTML character to use for separating each
-      # segment.
+      #  segment.
       # @return [String]
       #
       def get_breadcrumbs(separator = "»")