zen 0.2.8 → 0.3b

data/lib/vendor/sequel_sluggable.rb

@@ -0,0 +1,137 @@
+#:nodoc:
+module Sequel
+  #:nodoc:
+  module Plugins
+
+    # The Sluggable plugin creates hook that automatically sets
+    # 'slug' field to the slugged value of the column specified
+    # by :source option.
+    #
+    # You need to have "target" column in your model.
+    module Sluggable
+      #:nodoc:
+      DEFAULT_TARGET_COLUMN = :slug
+
+      # Plugin configuration
+      def self.configure(model, opts={})
+        model.sluggable_options = opts
+        model.sluggable_options.freeze
+
+        model.class_eval do
+          # Sets the slug to the normalized URL friendly string
+          #
+          # Compute slug for the value
+          #
+          # @param [String] String to be slugged
+          # @return [String]
+          define_method("#{sluggable_options[:target]}=") do |value|
+            sluggator = self.class.sluggable_options[:sluggator]
+
+            if sluggator.respond_to?(:call)
+              slug = sluggator.call(value, self)
+            end
+
+            if sluggator
+              slug ||= self.send(sluggator, value)
+            end
+
+            # If a slug is an empty string or a nil value it's value should be
+            # pulled from the source attribute.
+            if value.nil? or (value.respond_to?(:empty?) and value.empty?)
+              slug = self.send(self.class.sluggable_options[:source])
+            end
+
+            slug ||= to_slug(value)
+
+            super(slug)
+          end
+        end
+
+      end
+
+      #:nodoc:
+      module ClassMethods
+        attr_reader :sluggable_options
+
+        # Finds model by slug or PK
+        #
+        # @return [Sequel::Model, nil]
+        def find_by_pk_or_slug(value)
+          value.to_s =~ /^\d+$/ ? self[value] : self.find_by_slug(value)
+        end
+
+        # Finds model by Slug column
+        #
+        # @return [Sequel::Model, nil]
+        def find_by_slug(value)
+          self[@sluggable_options[:target] => value.chomp]
+        end
+
+        # Propagate settings to the child classes
+        #
+        # @param [Class] Child class
+        def inherited(klass)
+          super
+          klass.sluggable_options = self.sluggable_options.dup
+        end
+
+        # Set the plugin options
+        #
+        # Options:
+        # @param [Hash] plugin options
+        # @option frozen    [Boolean]      :Is slug frozen, default true
+        # @option sluggator [Proc, Symbol] :Algorithm to convert string to slug.
+        # @option source    [Symbol] :Column to get value to be slugged from.
+        # @option target    [Symbol] :Column to write value of the slug to.
+        def sluggable_options=(options)
+          raise ArgumentError, "You must provide :source column" unless options[:source]
+          sluggator = options[:sluggator]
+          if sluggator && !sluggator.is_a?(Symbol) && !sluggator.respond_to?(:call)
+            raise ArgumentError, "If you provide :sluggator it must be Symbol or callable."
+          end
+          options[:source]    = options[:source].to_sym
+          options[:target]    = options[:target] ? options[:target].to_sym : DEFAULT_TARGET_COLUMN
+          options[:frozen]    = options[:frozen].nil? ? true : !!options[:frozen]
+          @sluggable_options  = options
+        end
+      end
+
+      #:nodoc:
+      module InstanceMethods
+
+        # Sets a slug column to the slugged value
+        def before_create
+          super
+          target = self.class.sluggable_options[:target]
+          set_target_column unless self.send(target)
+        end
+
+        # Sets a slug column to the slugged value
+        def before_update
+          super
+          target = self.class.sluggable_options[:target]
+          frozen = self.class.sluggable_options[:frozen]
+          set_target_column if !self.send(target) || !frozen
+        end
+
+        private
+
+        # Generate slug from the passed value
+        #
+        # @param [String] String to be slugged
+        # @return [String]
+        def to_slug(value)
+          value.chomp.downcase.gsub(/[^a-z0-9]+/,'-')
+        end
+
+        # Sets target column with source column which
+        # effectively triggers slug generation
+        def set_target_column
+          target = self.class.sluggable_options[:target]
+          source = self.class.sluggable_options[:source]
+          self.send("#{target}=", self.send(source))
+        end
+      end # InstanceMethods
+    end # Sluggable
+  end # Plugins
+end # Sequel

data/lib/yard/tags.rb

@@ -0,0 +1,13 @@
+require 'yard'
+
+# The @map tag is used to indicate at what URI a controller is mapped.
+YARD::Tags::Library.define_tag('Mapped URI', :map)
+
+# The @permission tag can be used to define the required permissions.
+YARD::Tags::Library.define_tag('Required permissions', :permission)
+
+# The @event tag is a tag that indicates all the available events in a block of
+# code.
+YARD::Tags::Library.define_tag('Available Events', :event)
+
+YARD::Tags::Library.visible_tags += [:permission, :map, :event]

data/lib/zen.rb

@@ -1,123 +1,193 @@
-require 'rubygems'
 require 'ramaze'
-require 'yaml'
 
 Ramaze.setup(:verbose => false) do
-  gem 'sequel'          , ['~> 3.26']
-  gem 'bcrypt-ruby'     , ['~> 2.1.4'], :lib => 'bcrypt'
-  gem 'sequel_sluggable', ['~> 0.0.6']
-  gem 'loofah'          , ['~> 1.0.0']
+  gem 'sequel'      , ['~> 3.28.0']
+  gem 'bcrypt-ruby' , ['~> 3.0.1'], :lib => 'bcrypt'
+  gem 'loofah'      , ['~> 1.2.0']
+  gem 'ramaze-asset', ['~> 0.2.3'], :lib => 'ramaze/asset'
 end
 
-require __DIR__('zen/version')
+unless $LOAD_PATH.include?(__DIR__)
+  $LOAD_PATH.unshift(__DIR__)
+end
 
 ##
 # Main module for Zen, all other modules and classes will be placed inside this
-# module. This module loads all required classes and is used for starting the
-# application.
+# module.
 #
-# @author Yorick Peterse
 # @since  0.1
 #
 module Zen
-  # Update several paths so we can load helpers/layouts from the Zen gem
-  Innate::HelpersHelper.options.paths.push(__DIR__('zen'))
-  Ramaze.options.roots.push(__DIR__('zen'))
-
   class << self
-    ##
-    # Variable that will contain a database connection that was established
-    # using Sequel.connect.
-    #
-    # @author Yorick Peterse
-    # @since  0.2.6
-    #
+    # The database connection to use for Sequel.
     attr_accessor :database
 
+    # Instance of Ramaze::Asset::Environment to use for all backend assets.
+    attr_accessor :asset
+
+    # The root directory of the application.
+    attr_reader :root
+
     ##
-    # String containing the path to the root directory of the Zen application.
+    # Sets the root directory and adds the path to Ramaze.options.roots.
     #
-    # @author Yorick Peterse
-    # @since  0.2.6
+    # @since  0.3
     #
-    attr_accessor :root
+    def root=(path)
+      @root = path
+
+      if !Ramaze.options.roots.include?(@root)
+        Ramaze.options.roots.push(@root)
+      end
+    end
 
     ##
-    # Loads the database and the required models.
+    # Prepares Zen for the party of it's life.
     #
-    # @author Yorick  Peterse
-    # @since  0.1
+    # @since  0.3
     #
-    def init
-      # Initialize the database
-      Zen::Language.load('zen_general')
+    def start
+      if root.nil?
+        raise('You need to specify a valid root directory in Zen.root')
+      end
 
-      require __DIR__('zen/model/settings')
-      require __DIR__('zen/model/methods')
+      # Set up Ramaze::Cache manually. This makes it possible for the langauge
+      # files to cache their data in the custom cache without having to wait for
+      # Ramaze to set it up.
+      Ramaze::Cache.setup
+      Ramaze.options.setup.delete(Ramaze::Cache)
+
+      require 'zen/model/init'
+      require 'zen/model/methods'
+
+      setup_assets
+
+      require 'zen/package/all'
 
       # Load the global stylesheet and Javascript file if they're located in
       # ROOT/public/css/admin/global.css and ROOT/public/js/admin/global.js
-      publics = ::Ramaze.options.publics
+      load_global_assets
 
-      publics.each do |p|
-        p   = File.join(Zen.root, p)
-        css = File.join(p, 'admin/css/global.css')
-        js  = File.join(p, 'admin/js/global.js')
+      # Migrate all settings
+      begin
+        Settings::Setting.migrate
+      rescue => e
+        Ramaze::Log.warn(
+          'Failed to migrate the settings, make sure the database ' \
+            'table is up to date and that you executed rake db:migrate.'
+        )
+      end
 
-        Zen::Asset.stylesheet(['global'], :global => true) if File.exist?(css)
-        Zen::Asset.javascript(['global'], :global => true) if File.exist?(js)
+      Zen.asset.build(:javascript)
+      Zen.asset.build(:css)
+    end
+
+    private
+
+    ##
+    # Configures Ramaze::Asset and loads all the global assets.
+    #
+    # @since  0.3
+    #
+    def setup_assets
+      cache_path = File.join(root, 'public', 'minified')
+
+      if !File.directory?(cache_path)
+        Dir.mkdir(cache_path)
       end
+
+      Zen.asset = Ramaze::Asset::Environment.new(
+        :cache_path => cache_path,
+        :minify     => Ramaze.options.mode == :live
+      )
+
+      Zen.asset.serve(
+        :css,
+        [
+          'admin/css/zen/reset',
+          'admin/css/zen/grid',
+          'admin/css/zen/layout',
+          'admin/css/zen/general',
+          'admin/css/zen/forms',
+          'admin/css/zen/tables',
+          'admin/css/zen/buttons',
+          'admin/css/zen/messages'
+        ],
+        :name => 'zen_core'
+      )
+
+      Zen.asset.serve(
+        :javascript,
+        [
+          'admin/js/vendor/mootools/core',
+          'admin/js/vendor/mootools/more',
+          'admin/js/zen/lib/html_table',
+          'admin/js/zen/index'
+        ],
+        :name => 'zen_core'
+      )
+
+      require 'zen/asset_groups'
     end
 
     ##
-    # Method executed after everything has been set up and loaded.
+    # Loads a global CSS and JS file.
     #
-    # @author Yorick Peterse
-    # @since  0.2.6
+    # @since  0.3
     #
-    def post_init
-      # Migrate all settings
-      begin
-        plugin(:settings, :migrate)
-      rescue => e
-        Ramaze::Log.warn(
-          'Failed to migrate the settings, make sure the database ' + \
-            'table is up to date'
-        )
+    def load_global_assets
+      publics    = Ramaze.options.publics
+      css_loaded = false
+      js_loaded  = false
+
+      publics.each do |p|
+        p   = File.join(Zen.root, p)
+        css = File.join(p, 'admin', 'css', 'global.css')
+        js  = File.join(p, 'admin', 'js', 'global.js')
+
+        if File.exist?(css) and css_loaded == false
+          Zen.asset.serve(:css, ['admin/css/global'])
+          css_loaded = true
+        end
+
+        if File.exist?(js) and js_loaded == false
+          Zen.asset.serve(:javascript, ['admin/js/global'])
+          js_loaded = true
+        end
       end
     end
   end # class << self
 end # Zen
 
-# Load all classes/modules provided by Zen itself.
-require __DIR__('zen/validation')
-require __DIR__('zen/plugin')
-require __DIR__('zen/language')
-require __DIR__('zen/asset')
+require __DIR__('vendor/sequel_sluggable')
+require 'zen/version'
 
-# Load a set of modules into the global namespace
-include Zen::Plugin::SingletonMethods
-include Zen::Language::SingletonMethods
+Ramaze::Cache.options.names.push(:settings, :translations)
+Ramaze::Cache.options.settings     = Ramaze::Cache::LRU
+Ramaze::Cache.options.translations = Ramaze::Cache::LRU
 
-# Update the language path
-Zen::Language.options.paths.push(__DIR__('zen'))
-Zen::Language.load('zen_general')
+# Load all classes/modules provided by Zen itself.
+require 'zen/error'
+require 'zen/validation'
+require 'zen/language'
+require 'zen/event'
+require 'zen/model/helper'
+require 'zen/languages'
 
-# Load all additional files
-require __DIR__('zen/plugin/helper')
-require __DIR__('zen/plugin/markup/lib/markup')
+Ramaze::HelpersHelper.options.paths.push(__DIR__('zen'))
+Ramaze.options.roots.push(__DIR__('zen'))
+Zen::Language.options.paths.push(__DIR__('zen/language'))
+
+include Zen::Language::SingletonMethods
 
-require __DIR__('zen/package')
-require __DIR__('zen/theme')
+require 'zen/markup'
+require 'zen/package'
+require 'zen/theme'
 
 # Load all the base controllers
-require __DIR__('zen/controller/base_controller')
-require __DIR__('zen/controller/frontend_controller')
-require __DIR__('zen/controller/admin_controller')
-require __DIR__('zen/controller/main_controller')
-require __DIR__('zen/controller/preview')
-
-# Load the cache for the settings. This has to be done outside any of the init
-# methods as that would make it impossible to set a custom cache.
-Ramaze::Cache.options.names.push(:settings)
-Ramaze::Cache.options.settings = Ramaze::Cache::LRU
+require 'zen/controller/base_controller'
+require 'zen/controller/frontend_controller'
+require 'zen/controller/admin_controller'
+require 'zen/controller/main_controller'
+require 'zen/controller/preview'
+require 'zen/controller/translations'

data/lib/zen/asset_groups.rb

@@ -0,0 +1,85 @@
+Zen.asset.register_asset_group(:tabs) do |asset, controller, methods|
+  asset.serve(
+    :javascript,
+    ['admin/js/zen/lib/tabs'],
+    :name       => 'zen_tabs',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+
+  asset.serve(
+    :css,
+    ['admin/css/zen/tabs'],
+    :name       => 'zen_tabs',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+end
+
+Zen.asset.register_asset_group(:datepicker) do |asset, controller, methods|
+  asset.serve(
+    :javascript,
+    ['admin/js/vendor/datepicker'],
+    :name       => 'vendor_datepicker',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+
+  asset.serve(
+    :css,
+    ['admin/css/zen/datepicker'],
+    :name       => 'vendor_datepicker',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+end
+
+Zen.asset.register_asset_group(:window) do |asset, controller, methods|
+  asset.serve(
+    :javascript,
+    ['admin/js/zen/lib/window'],
+    :name       => 'zen_window',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+
+  asset.serve(
+    :css,
+    ['admin/css/zen/window'],
+    :name       => 'zen_window',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+end
+
+Zen.asset.register_asset_group(:editor) do |asset, controller, methods|
+  asset.load_asset_group(:window, controller, methods)
+
+  asset.serve(
+    :javascript,
+    [
+      'admin/js/zen/lib/editor',
+      'admin/js/zen/lib/editor/markdown',
+      'admin/js/zen/lib/editor/textile'
+    ],
+    :name       => 'zen_editor',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+
+  asset.serve(
+    :css,
+    ['admin/css/zen/editor'],
+    :name       => 'zen_editor',
+    :controller => controller,
+    :minify     => true,
+    :methods    => methods
+  )
+end