zen 0.2.8 → 0.3b

data/.gems

@@ -0,0 +1,20 @@
+# Production dependencies.
+ramaze
+sequel
+bcrypt-ruby
+loofah
+shebang
+ramaze-asset
+
+# Development dependencies, no need for specific versions.
+rdiscount
+bacon
+yard
+capybara
+sqlite3
+defensio
+simplecov
+webmock
+RedCloth
+pg
+mysql2

data/.mailmap

@@ -1,2 +1,3 @@
-YorickPeterse <yorickpeterse@gmail.com> YorickPeterse <info@yorickpeterse.com>
-YorickPeterse <yorickpeterse@gmail.com> Yorick Peterse <info@yorickpeterse.com>
+Yorick Peterse <yorickpeterse@gmail.com> YorickPeterse <info@yorickpeterse.com>
+Yorick Peterse <yorickpeterse@gmail.com> Yorick Peterse <info@yorickpeterse.com>
+Yorick Peterse <yorickpeterse@gmail.com> YorickPeterse <yorickpeterse@gmail.com>

data/.rvmrc

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-rvm use --create 1.9.2@zen
+rvm use --create 1.9.3@zen

data/.travis.yml

@@ -1,11 +1,22 @@
-script: "gem install ramaze; rake test"
+script: "rake setup; rake test:default"
 rvm:
   - 1.9.2
+  - 1.9.3
 
 notifications:
-  disabled: true
+  email:
+    - yorickpeterse@gmail.com
 
 branches:
   only:
     - develop
     - master
+
+env:
+  - 'ADAPTER=sqlite'
+  - 'ADAPTER=mysql2 DATABASE=zen_dev'
+  - 'ADAPTER=postgres DATABASE=zen_dev USERNAME=postgres'
+
+before_script:
+  - "mysql -e 'CREATE DATABASE zen_dev;'"
+  - "psql -c  'CREATE DATABASE zen_dev;' -U postgres"

data/.yardopts

@@ -0,0 +1,13 @@
+./lib/zen/**/*.rb ./lib/zen.rb
+-m markdown
+-M rdiscount
+-o ./doc
+-r ./README.md
+-e ./lib/yard/tags.rb
+--private
+--protected
+--asset ./guide/_static:_static
+--asset ./guide/css/common.css:css/common.css
+-
+./guide/*.md
+LICENSE

data/AUTHORS

@@ -1,4 +1,4 @@
 Following persons have contributed to Zen.
 (Sorted by number of submitted patches, then alphabetically)
 
-   184 YorickPeterse <yorickpeterse@gmail.com>
+   308 Yorick Peterse <yorickpeterse@gmail.com>

data/README.md

@@ -1,82 +1,96 @@
-# README
-
-Zen is a modular CMS written on top of the awesome Ramaze framework. Zen was
-built out of the frustration with Expression Engine, a popular CMS built on top
-of the Codeigniter framework which in turn is written using PHP. While I really
-like Codeigniter, ExpressionEngine and EllisLab there were several problems
-that bothered me. So I set out to write a system that's loosely based on
-ExpressionEngine but fits my needs. Because of this certain features may seem
-similar to those provided by EE and while at certain points there are
-similarities there are also pretty big differences.
+# Zen
+
+Zen is a flexible Content Management System that gives you full control over
+your content and presentation without limiting your possibilities. One of the
+key features of Zen is that you're able to define your own content types and
+fields. No longer are you limited to only filling in a title and a body field,
+instead you can just create your own as you see fit. Another interesting feature
+is that Zen allows you to "embed" Ramaze applications inside Zen (although they
+might need some minor changes).
+
+Zen was originally inspired by [Expression Engine][ee]. EE is based on a similar
+idea of allowing you to define your own fields and such. As much as I enjoyed
+using EE at the time there were several very annoying limitations/problems. The
+admin interface was a mess, the interal API wasn't very well organized and the
+database design was even worse (for example, settings are serialized and encoded
+using some algorithm). This started off the idea of Zen: something that's based
+on a similar idea but solves all the problems I was having with Expression
+Engine.
+
+When building Zen I tried to make it pleasant to use, whether you're a
+developer, designer or just a user. I tried to make the administration interface
+as easy to use (although it has it's quirks) as well as making the internal API
+a breeze to use. Another important part is performance. If I'm going to use a
+content management system it should be fast and shouldn't use excessive amounts
+of RAM. It's hard to say how fast Zen really is as it depends on your
+configuration and hardware but one thing is sure: out of the box it should be
+able to handle lots of requests per second without any trouble.
+
+Some of the core features of Zen are listed below. Note that these are only a
+small portion of what it can do.
+
+* Define your own content fields (called "custom fields") with their own type,
+  markup, rules and so on.
+* Fine grained control over user access thanks to an easy to use permission
+  system.
+* Be able to use everything Ramaze has to offer. Want to use your own admin
+  layout? No problem! Want to drop in an existing Ramaze application? Sure!
+* A well documented, tested and easy to understand API.
+* A database structure that doesn't make you cry.
+
+## Chapters
+
+* {file:installation Installation}
+* {file:getting_started Getting Started}
+* {file:hacking Hacking/Contributing}
+* {file:changelog Changelog}
+* {Categories Categories}
+  * {Categories::Controller::CategoryGroups Managing Category Groups}
+  * {Categories::Controller::Categories Managing Categories}
+  * {Ramaze::Helper::CategoryFrontend#get_categories Categories & Templates}
+* {Comments Comments}
+  * {Comments::Controller::Comments Managing Comments}
+  * {Comments::Controller::CommentsForm Submitting Comments}
+  * {Comments::AntiSpam Validating Comments For Spam}
+  * {Ramaze::Helper::CommentFrontend#get_comments Comments & Templates}
+* {CustomFields Custom Fields}
+  * {CustomFields::Controller::CustomFieldGroups Managing Groups}
+  * {CustomFields::Controller::CustomFields Managing Fields}
+  * {CustomFields::Controller::CustomFieldTypes Managing Types}
+  * {CustomFields::BlueFormParameters Generating BlueForm Parameters}
+* {Menus Menus}
+  * {Menus::Controller::Menus Menu Management}
+  * {Menus::Controller::MenuItems Managing Menu Items}
+  * {Ramaze::Helper::MenuFrontend#render_menu Menus & Templates}
+* {Sections Sections & Section Entries}
+  * {Sections::Controller::Sections Managing Sections}
+  * {Sections::Controller::SectionEntries Managing Section Entries}
+  * {Ramaze::Helper::SectionFrontend#get_entries Section Entries & Templates}
+* {Settings}
+  * {Settings::Controller::Settings Managing Settings}
+  * {Settings::SingletonMethods#get_setting Retrieving Settings}
+* {Users Users, User Groups and Permissions}
+  * {Users::Controller::Users Managing Users}
+  * {Users::Controller::UserGroups Managing User Groups}
+* {Zen::Package Packages}
+* {Zen::Theme Themes}
+* {Zen::Language Localization}
+* {Zen::Event Events}
+* {Zen::Validation Validating Objects}
+* {file:asset_management Asset Management}
+* {file:javascript Javascript API}
 
 ## Requirements
 
-* Ramaze 2011.01.30 or newer
-* Ruby 1.9.2
-* A database (MySQL, PostgreSQL, etc)
-
-## Installation
-
-Installing Zen using Rubygems is probably the easiest way:
-
-    $ gem install zen
-    $ zen create application_name
-
-If you like to hack with the core of Zen it's best to install it using Git:
-
-    $ git clone git://github.com/zen-cms/Zen-Core.git
-    $ cd zen-core
-    $ rake build:gem
-
-## Database Support
-
-Technically Zen should run on any given DBMS that's supported by Sequel as Zen
-doesn't use any DBMS specific field types. However, there might be a chance that
-it won't work. If you happen to have any problems getting Zen running using your
-database of choice feel free to submit a ticket or post it on the mailing
-list.
-
-The Zen website itself is tested and served using MySQL, SQLite3 works just as
-fine and PostgreSQL will be tested in the near future.
-
-## Running Zen
-
-Zen can be run using any webserver as long as it supports Rack. Thin, Unicorn or
-Passenger, they should all work. The main website of Zen is served using Unicorn
-and Nginx, development is done using WEBRick and Unicorn.
-
-## Documentation
-
-The documentation (both the userguide and the API docs) can be found on the
-website, located [here][zen documentation].
-
-## Hacking/Contributing
-
-Zen follows a relatively strict set of guidelines when it comes to developing
-core features and making sure everything goes along smoothly. When working with
-Git a branch model based on [nvie's branch model][nvie branch model] is used.
-This means that the "master" branch is directly used for pushing Gems and thus
-should *always* contain stable code. Develop is used to contain less stable (but
-not unstable) commits that will be pushed into "master" from time to time.  All
-other branches, e.g. "rspec2" will be used for individual features.
-
-Besides following this model developers are also expected to write tests using
-either RSpec or Capybara for their features. Capybara is used to test
-controllers and browser based tests while RSpec is used to test libraries,
-helpers, etc.
-
-## Coding Standards
-
-* 2 spaces per indentation level for Ruby code.
-* 4 spaces per indentation level for Javascript, CSS and HTML.
-* Document your code, that includes CSS and Javascript files.
-* No tabs at all times.
-* Markdown is used for all markup.
-* The maximum width of each line should be no more than 80 characters, this
-  makes it easier to read code in terminals or when using split view modes. The
-  limit used to be 90 characters but this was decreased to fit the Ruby coding
-  standards. Existing code using the 90 character limit will be changed over
-  time.
+* Ruby >= 1.9.2 (Rubinius, jruby and others are not supported).
+* Ramaze 2011.10.23 or newer.
+* A SQL database supported by Sequel. Zen has been tested and confirmed to
+  work on MySQL, SQLite3 and PostgreSQL. You'll also need the required gems for
+  these DBMS' such as "mysql2" for MySQL and "pg" for PostgreSQL.
+* A Rack compatible server such as Thin or Unicorn.
+* A library to convert your markup of choice to HTML. Zen by default has support
+  for Textile using Redcloth and Markdown using RDiscount. RDiscount and
+  RedCloth are installed automatically when needed.
 
 ## Community
 
@@ -88,6 +102,30 @@ in any of the following channels on Freenode:
 
 * \#forrst-chat
 * \#ramaze
+* \#ruby-lang
+
+## Websites Using Zen
+
+* http://yorickpeterse.com/
+* http://ramaze.net/
+* http://zen-cms.com/
+
+If you've built a website using Zen and you'd like to have it listed here sent
+an Email to me (yorickpeterse [at] gmail [dot] com) or send an Email to the
+mailing list.
+
+## Special Thanks
+
+While developing Zen I had a lot of help from various people and I'd like to
+thank them for that. In particular I'd like to thank the following people:
+
+* Michael Fellinger (manveru, creator of Ramaze/Innate) for his help and for
+  creating such a wonderful framework.
+* Yukihiro Matsumoto for creating Ruby.
+* \#ramaze on Freenode, lots of people in there helped me getting started with
+  Ramaze when I first started working with it around september 2010.
+* EllisLab for creating ExpressionEngine, the system Zen was inspired by.
+* Loren Segal for creating YARD and helping me out with various issues.
 
 ## License
 
@@ -96,5 +134,5 @@ open the file "LICENSE".
 
 [zen website]: http://zen-cms.com/
 [zen documentation]: http://zen-cms.com/userguide/index.html
-[nvie branch model]: http://nvie.com/posts/a-successful-git-branching-model/
 [mailing list]: https://groups.google.com/forum/#!forum/zen-cms
+[ee]: http://expressionengine.com/

data/Rakefile

@@ -1,10 +1,9 @@
-require File.expand_path('../lib/zen', __FILE__)
+require 'rubygems'
 
-module Zen
-  Gemspec = Gem::Specification::load(__DIR__('zen.gemspec'))
-end
+Zen::Gemspec = Gem::Specification::load(
+  File.expand_path('../zen.gemspec', __FILE__)
+)
 
-# Load all tasks
-Dir.glob(File.expand_path('../lib/zen/task/*.rake', __FILE__)).each do |f|
-  import(f)
+Dir.glob(File.expand_path('../lib/zen/task/*.rake', __FILE__)).each do |task|
+  import(task)
 end

data/bin/zen

@@ -1,9 +1,16 @@
 #!/usr/bin/env ruby
-
 require 'ramaze'
-require 'optparse'
 
-require __DIR__('../lib/zen/version')
-require __DIR__('../lib/zen/bin/runner')
+Ramaze.setup(:verbose => false) do
+  gem 'shebang', ['~> 0.1']
+end
+
+unless $LOAD_PATH.include?(__DIR__('../lib'))
+  $LOAD_PATH.unshift(__DIR__('../lib'))
+end
+
+require 'zen/version'
+require 'zen/bin/create'
+require 'zen/bin/default'
 
-Zen::Bin::Runner.run
+Shebang.run

data/guide/asset_management.md

@@ -0,0 +1,117 @@
+# Asset Management
+
+Zen comes with an asset manager powered by [Ramaze::Asset][ramaze-asset]. Before
+v0.3 Zen used to come with it's own asset manager (``Zen::Asset``) but this
+module is no longer available as of v0.3.
+
+Assets can be loaded using the attribute ``Zen.asset``. This attribute contains
+an instance of ``Ramaze::Asset::Environment`` and will automatically minify
+files based on ``Ramaze.options.mode``. If the mode is ``:live`` all the files
+will be minified. Once minified these files will be stored in
+``public/minified`` in the directory stored in ``Zen.root``. If the
+``minified/`` directory doesn't exist it will be automatically created.
+
+Assets can be loaded in two different ways, either by calling
+``Zen.asset.serve()`` directly or by using the helper ``Ramaze::Helper::Asset``.
+The asset helper is loaded in the admin controller and therefor available to all
+controllers that extend it. Loading assets using the first method works as
+following:
+
+    Zen.asset.serve(:javascript, ['admin/js/vendor/mootools/core'])
+
+The first parameter is the type of files to load. Out of the box you can use
+``:javascript`` and ``:css``. The second parameter is an array of paths relative
+to ``/`` (with or without file extensions). The third parameter can be used to
+specify extra options. See [Ramaze::Asset::Environment][ramaze-env] URL for more
+information.
+
+The second way of loading assets is by using the Asset helper. This helper has a
+shorter syntax and loads the assets *only* for the calling controller. Generally
+it's better to load assets for a specific controller rather than globally
+loading them. Using this helper you can load assets in your class declaration as
+following:
+
+    class Posts < Zen::Controller::AdminController
+      map '/admin/posts'
+
+      serve(:javascript, ['admin/js/vendor/mootools/core'])
+    end
+
+The ``serve()`` method has the same syntax as ``Zen.asset.serve()``, it just
+automatically fills the ``:controller`` option.
+
+An example of loading a set of files with various options (taken from the Users
+package):
+
+    serve(
+      :javascript,
+      ['admin/js/users/lib/access_rules', 'admin/js/users/access_rules'],
+      :methods => [:edit, :new],
+      :name    => 'users'
+    )
+
+## Asset Groups
+
+Loading multiple assets, especially ones that ship with Zen, can be a bit
+annoying. Luckily ``Ramaze::Asset`` provides a nice way of dealing with groups
+of assets: asset groups. Asset groups are simple blocks that are invoked on the
+an instance of ``Ramaze::Asset::Environment`` (the one they're added to). Adding
+an asset group can be done as following:
+
+    Zen.asset.register_asset_group(:my_asset_group) do |asset|
+      asset.serve(...)
+    end
+
+Loading that particular asset group would be done as following:
+
+    Zen.asset.load_asset_group(:my_asset_group)
+
+All additional parameters passed to ``Zen.asset.load_asset_group()`` will be
+passed to the block that defines the asset group. This makes it possible for
+asset groups to know for what controller they should be loaded:
+
+    Zen.asset.register_asset_group(:my_asset_group) do |asset, controller|
+      asset.serve(
+        :javascript,
+        ['admin/js/vendor/mootools/core'],
+        :controller => controller
+      )
+    end
+
+    Zen.asset.load_asset_group(:my_asset_group, Sections::Controller::Sections)
+
+The Asset helper also contains a method that makes it a bit easier to load
+asset groups in your controllers. This method is called ``load_asset_group()``.
+The first parameter is an array of groups to load and the second parameter an
+array of methods for which to load those groups:
+
+    class Posts < Zen::Controller::AdminController
+      map '/'
+
+      # Loads the :tabs group for the index() method
+      load_asset_group([:tabs], [:index])
+    end
+
+### Available Groups
+
+Zen comes with the following asset groups that you can use:
+
+* tabs
+* datepicker
+* window
+* editor
+
+## Global Assets
+
+When starting up Zen will check if it can find a global stylesheet and
+Javascript file. These files can be used to make changes to the admin panel
+without having to go through the process of creating packages or re-defining the
+entire layout. These files are called "global.css" and "global.js" and (in order
+to use them) should be placed in the following directories (where ROOT is the
+root directory of the application):
+
+* ROOT/admin/css/global.css
+* ROOT/admin/js/global.js
+
+[ramaze-asset]: https://github.com/yorickpeterse/ramaze-asset
+[ramaze-env]: https://github.com/YorickPeterse/ramaze-asset/blob/master/lib/ramaze/asset/environment.rb