zen 0.2.4.1 → 0.2.5

data/lib/zen/asset.rb

@@ -0,0 +1,258 @@
+require 'ramaze/gestalt'
+
+#:nodoc:
+module Zen
+  ##
+  # The Asset module is a module used to register what Javascript files and stylesheets
+  # should be loaded for the current request. This can be very useful if you want to add
+  # a widget to all pages or override a certain stylesheet.
+  #
+  # ## Adding Assets
+  #
+  # Assets can be added by calling either Zen::Asset.stylesheet or Zen::Asset.javascript.
+  # Both take an array of files and a hash with some configuration options, for more info
+  # on the exact usage and all the available parameters see the individual methods. Here
+  # are a few quick examples of loading files:
+  #
+  #     # Load 3 Javascript files of which 2 will be loaded globally
+  #     Zen::Asset.javascript(
+  #       ['mootools/core', 'mootools/more'], :global => true,
+  #     )
+  #
+  #     Zen::Asset.javascript(['application'], :controller => self)
+  #
+  #     # Do the same with a few stylesheets
+  #     Zen::Asset.stylesheet(['admin/css/forms'], :global => true)
+  #     Zen::Asset.stylesheet(['style'], :controller => self)
+  #
+  # ## Customizing Options
+  #
+  # This module uses Innate::Optioned to provide a few options that can be changed. The
+  # following options are available:
+  #
+  # * prefix: The global prefix to use for all assets, set to "admin" by default.
+  # * javascript_prefix: The prefix to use for all Javascript files on top of the global
+  # prefix.
+  # * stylesheet_prefix: Similar to the javascript_prefix option but for stylesheets.
+  #
+  # ## Building Assets
+  #
+  # Building assets shouldn't be required as Zen already does this but if you happen to 
+  # need it you can build the files as following:
+  #
+  #     Zen::Asset.build(:stylesheet)
+  #     Zen::Asset.build(:javascript)
+  #
+  # ## Controller Usage
+  #
+  # While this module can be called by any other piece of code the class 
+  # Zen::Controller::AdminController provides shortcuts to Zen::Asset.javascript and 
+  # Zen::Asset.stylesheet. These shortcuts work identical but are defined as class methods
+  # and thus can be used inside your class declaration:
+  #
+  #     class Something < Zen::Controller::AdminController
+  #       stylesheet ['reset'], :global => true
+  #     end
+  #
+  # @author Yorick Peterse
+  # @since  0.2.5
+  #
+  module Asset
+    include ::Innate::Optioned
+
+    class << self
+      include ::Innate::Trinity
+    end
+
+    options.dsl do
+      o 'Prefix for both Javascript files and stylesheets', :prefix           , 'admin'
+      o 'Prefix for Javascript files on top of :prefix'   , :javascript_prefix, 'js'
+      o 'Prefix for stylesheets on top of :prefix'        , :stylesheet_prefix, 'css'
+    end
+
+    ##
+    # Hash containing all the global and controller specific stylesheets that have to be
+    # loaded when calling build_stylesheets.
+    #
+    # @author Yorick Peterse
+    # @since  0.2.5
+    #
+    Stylesheets = {
+      :global => []
+    }
+
+    ##
+    # Hash containing all the global and controller specific stylesheets to load when
+    # calling build_javascripts.
+    #
+    # @author Yorick Peterse
+    # @since  0.2.5
+    #
+    Javascripts = {
+      :global => []
+    }
+
+    ##
+    # Registers the given Javascripts files so that they're either loaded for the
+    # current action or for all actions. Note that the first argument of this method
+    # should always be an array.
+    #
+    # @example
+    #  # Loads /admin/js/users/access_rules.js for the current action only
+    #  Zen::Asset.javascript ['users/access_rules']
+    #
+    #  # This would load the file globally
+    #  Zen::Asset.javascript ['users/access_rules'], :global => true
+    #
+    # @author Yorick Peterse
+    # @since  0.2.5
+    # @param  [Array] files An array of Javascript files (without their extensions) to
+    # load relatively to the root of the application (/).
+    # @param  [Hash] options A hash containing additional options.
+    # @option options [TrueClass] :global When set to true the specified files will be
+    # loaded globally rather than just for the current action.
+    # @option options [String/Symbol] controller The name of the controller for which
+    # the specified files should be loaded.
+    #
+    def self.javascript(files, options = {})
+      options = {
+        :prefix => File.join('/', self.options.prefix, self.options.javascript_prefix),
+        :type   => :javascript
+      }.merge(options)
+
+      process(files, options)
+    end
+
+    ##
+    # Registers a number of stylesheets that can either be loaded globally or for the
+    # current action.
+    #
+    # @example
+    #  Zen::Asset.stylesheet ['foobar/admin_template'], :global => true
+    #
+    # @author Yorick Peterse
+    # @since  0.2.5
+    # @param  [Array] files A list of stylesheets (without their extensions) to load.
+    # @param  [Hash] options A hash containing additional options to use.
+    # @option options [TrueClass] :global When set to true all the specified stylesheets
+    # will be loaded globally rather than just for the current action.
+    # @option options [String/Symbol] controller The name of the controller for which
+    # the specified files should be loaded. 
+    #
+    def self.stylesheet(files, options = {})
+      options = {
+        :prefix => File.join('/', self.options.prefix, self.options.stylesheet_prefix),
+        :type   => :stylesheet
+      }.merge(options)
+
+      process(files, options)
+    end
+
+    ##
+    # Builds either all Javascript files or stylesheets. This method will load both the
+    # global and action specific files.
+    #
+    # @example
+    #  # Build the HTML tags for all stylesheets
+    #  Zen::Asset.build(:stylesheet)
+    #
+    #  # Build the HTML tags for all Javascript files
+    #  Zen::Asset.build(:javascript)
+    #
+    # @author Yorick Peterse
+    # @since  0.2.5
+    # @param  [Symbol] type The type of assets to build.
+    # @return [String] The HTML tags for all the assets.
+    # 
+    def self.build(type)
+      type       = type.to_sym
+      attrs      = {}
+      controller = action.node.to_s.to_sym
+      gestalt    = Ramaze::Gestalt.new
+
+      # Set the basic elements of the tag
+      if type === :stylesheet
+        tag         = :link
+        value       = :href
+        attrs[:rel] = 'stylesheet'
+        files       = Stylesheets
+      else
+        tag   = :script
+        value = :src
+        files = Javascripts
+      end
+
+      # Get all the files to build
+      if !files[controller].nil?
+        files = files[:global] + files[controller]
+      else
+        files = files[:global]
+      end
+
+      # Build the tags
+      files.each do |f|
+        tag_attrs = {
+          value => f
+        }.merge(attrs)
+
+        if type === :javascript
+          gestalt.send(tag, '', tag_attrs)
+        else
+          gestalt.send(tag, tag_attrs)
+        end
+      end
+
+      return gestalt.to_s
+    end
+
+    private
+
+    ##
+    # Stores the given files in the correct hash based on the specified options.
+    #
+    # @example
+    #  process(['foobar', 'baz'], :global => false, :type => :javascript, :prefix => 'js')
+    #
+    # @author Yorick Peterse
+    # @since  0.2.5
+    # @param  [Array] files An array of files to load.
+    # @param  [Hash] options A hash containing all the required options.
+    # @option options [TrueClass] :global Specifies that all the files should be loaded
+    # globally.
+    # @option options [Symbol] :type The type of asset that's loaded, can either be
+    # :javascript or :stylesheet.
+    # @option options [String] :prefix The prefix to use for all the assets.
+    # @option options [TrueClass] :global
+    # @option options [Symbol/String] :controller
+    #
+    def self.process(files, options)
+      # Determine whether the files should be loaded globally
+      if options.key?(:global) and options[:global] === true
+        key = :global
+      else
+        key = options[:controller].to_s.to_sym
+      end
+
+      # Determine where to save the data
+      if options[:type] === :javascript
+        save = Javascripts
+        ext  = '.js'
+      else
+        save = Stylesheets
+        ext  = '.css'
+      end
+
+      # Add all the files
+      files.each do |f|
+        f           = f.to_s + ext
+        f           = File.join(options[:prefix], f)
+        save[key] ||= []
+
+        if !save[key].include?(f)
+          save[key].push(f)
+        end
+      end
+    end
+
+  end
+end

data/lib/zen/bin/app.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+
+##
+# Command that can be used to generate a new application.
+#
+# @author Yorick Peterse
+# @since  0.2.5
+# 
+command :app do |cmd|
+
+  # Set a few details of the command
+  cmd.syntax      = '$ zen app [NAME]'
+  cmd.description = 'Creates a new application powered by Zen.'
+
+  cmd.option('-f', TrueClass, 'Overwrites any existing application.')
+
+  # The action to execute when the command is invoked
+  cmd.action do |args, opts|
+    if args.empty?
+      abort 'You need to specify a name for the application.'
+    end
+
+    name  = args[0]
+    app   = File.join('./', name)
+    proto = File.expand_path('../../../../proto/app', __FILE__)
+    
+    if File.directory?(app) and !opts.f
+      abort "The application #{app} alread exists, use -f to overwrite it."
+    else
+      FileUtils.rm_rf(app)
+    end
+
+    # Copy the prototype
+    begin
+      FileUtils.cp_r(proto, app)
+      puts "The application has been generated and saved in #{app}"
+    rescue => e
+      abort "Failed to generate the application: #{e.message}"
+    end
+  end
+
+end

data/lib/zen/controller/admin_controller.rb

@@ -1,7 +1,7 @@
 #:nodoc:
 module Zen
   #:nodoc:
-  module Controllers
+  module Controller
     ##
     # The admin controller is a base controller that should be extended by all controllers
     # for the backend of Zen. This controller will automatically check to see if the 
@@ -15,26 +15,14 @@ module Zen
     # Users controller, mapped to /admin/users/login. If a user isn't logged in he/she 
     # will be redirected to the login page.
     #
-    # ## Helpers
-    #
-    # The admin controller loads the following helpers:
-    #
-    # * CSRF
-    # * BlueForm
-    # * Common
-    # * Breadcrumb
-    # * User
-    # * ACL
-    # * Asset
-    #
     # @author Yorick Peterse
     # @since  0.1
     #
-    class AdminController < Zen::Controllers::BaseController
+    class AdminController < Zen::Controller::BaseController
       layout :admin
       engine :etanni
-      helper :blue_form, :common, :breadcrumb, :user, :acl, :asset
-      
+      helper :blue_form, :common, :breadcrumb, :user, :acl
+
       ##
       # The initialize method is called upon class initalization and is used to process several
       # items before loading the controller(s) for the current extension.
@@ -44,37 +32,66 @@ module Zen
       #
       def initialize
         super
-        
-        # Load our CSS and Javascript files
-        require_css(
-          'boilerplate', 'grid', 'layout', 'general', 'forms', 'tables', 'buttons',
-          'tabs', 'notifications', 'editor'
-        )
-
-        require_js('zen/tabs', 'zen/notification', 'zen/modal', 'zen/editor/base',
-          'zen/editor/drivers/html', 'zen/editor/drivers/textile', 'zen/editor/drivers/markdown',
-          'zen/init'
-        )
-        
+                
         # Only allow users to access admin/users/login when they aren't logged in
         if request.env['SCRIPT_NAME'] != 'admin/users/' and request.env['PATH_INFO'] != '/login'
           redirect '/admin/users/login' unless logged_in?
         end
 
-        # Hash containing all available formats for input fields
-        @format_hash = {
-          'html'     => lang('zen_general.special.format_hash.html'),
-          'textile'  => lang('zen_general.special.format_hash.textile'),
-          'markdown' => lang('zen_general.special.format_hash.markdown'),
-          'plain'    => lang('zen_general.special.format_hash.plain')
-        }
-
         @boolean_hash = {
           true  => lang('zen_general.special.boolean_hash.true'),
           false => lang('zen_general.special.boolean_hash.false')
         }.invert
+      end
+ 
+      ##
+      # Shortcut for Zen::Asset.stylesheet.
+      #
+      # @author Yorick Peterse
+      # @see    Zen::Asset.stylesheet
+      # @since  0.2.5
+      #
+      def self.stylesheet(files, options = {})
+        options = {
+          :controller => self
+        }.merge(options)
 
+        ::Zen::Asset.stylesheet(files, options)
       end
+
+      ##
+      # Shortcut for Zen::Asset.javascript.
+      #
+      # @author Yorick Peterse
+      # @see    Zen::Asset.javascript
+      # @since  0.2.5
+      #
+      def self.javascript(files, options = {})
+        options = {
+          :controller => self
+        }.merge(options)
+
+        ::Zen::Asset.javascript(files, options)
+      end
+
+      # Load all stylesheets globally
+      stylesheet(
+        [
+          'reset', 'grid', 'layout', 'general', 'forms', 'tables', 'buttons', 
+          'notifications'
+        ], 
+        :global => true
+      )
+
+      # Load all global javascript files
+      javascript(
+        [
+          'mootools/core', 'mootools/more', 'vendor/yepnope', 'zen/notification', 
+          'zen/init', 
+        ],
+        :global => true
+      )
+
     end
   end
 end

data/lib/zen/controller/base_controller.rb

@@ -1,7 +1,7 @@
 #:nodoc:
 module Zen
   #:nodoc:
-  module Controllers
+  module Controller
     ##
     # The BaseController is extended by both the FrontendController and the 
     # BackendController. This controller is mostly used to set and retrieve data that's 
@@ -24,15 +24,20 @@ module Zen
       #
       def initialize
         super
-        
-        # Get all settings
-        if !@settings
-          @settings = ::Settings::Models::Setting.get_settings
+
+        # Store the settings data if this is the first time we're loading the controller
+        if ::Zen::Settings.empty?
+          ::Settings::Model::Setting.get_settings.each do |k, v|
+            ::Zen::Settings[k] = v
+          end
         end
-        
+
         # Override the language
-        ::Zen::Language.options.language = @settings[:language]
-        ::Zen::Language.load('zen_general')
+        if ::Zen::Settings[:language] != ::Zen::Language.options.language
+          # Reload the language pack
+          ::Zen::Language.options.language = ::Zen::Settings[:language]
+          ::Zen::Language.load('zen_general')
+        end
       end
     end
   end