kajam 1.0.3.rc2

data/.gitignore

@@ -0,0 +1,20 @@
+config/database.yml
+db/*.db
+log/*.log
+pkg
+tmp/*
+.DS_Store
+.svn
+TAGS
+public/tmp
+public/stylesheets/admin/styles.css
+spec/datasets/tmp
+*.tmproj
+.idea
+rerun.txt
+*.swp
+kajam-*.gem
+.rvmrc
+Gemfile.lock
+.bundle
+.project

data/INSTALL

@@ -0,0 +1,35 @@
+
+== Installation and Setup
+
+Once you have extracted the files into the directory where you would like to
+install Kajam:
+
+1. Create the MySQL/PostgreSQL/SQLite/SQL Server/DB2 databases for your Web
+   site. You only need to create the "production" database, but you may also
+   want to create the "development" and "test" databases if you are developing
+   extensions or running tests.
+
+2. Edit config/database.yml to taste.  There are example files available for
+   various databases in the config directory.
+
+3. Run the database bootstrap rake task:
+   
+     % rake production db:bootstrap
+   
+   (If you would like bootstrap your development database run `rake
+   development db:bootstrap`.)
+   
+   If you get the error "no such file to load -- spec/rake/spectask" please
+   install Rspec (gem install rspec).
+
+4. Start it like a normal Rails application. To test execute:
+   
+     % script/server -e production
+   
+   And open your Web browser on port 3000 (http://localhost:3000). The
+   administrative interface is available at /admin/. By default the bootstrap
+   rake task creates a user called "admin" with a password of "kajam".
+
+When using Kajam on a production system you may also need to set permissions
+on the public and cache directories so that your Web server can access those
+directories with the user that it runs under.

data/LICENSE

@@ -0,0 +1,21 @@
+== MIT License
+
+Copyright (c) 2006-2009, The ResetTech Dev Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,84 @@
+Welcome to Kajam
+================
+
+Kajam is a open source lightweight content management system for middle and small teams.
+
+Kajam features:
+====
+
+* An elegant user interface
+* The ability to arrange pages in a hierarchy
+* Flexible templating with layouts, snippets, page parts, and a custom tagging
+  language (Radius: http://radius.rubyforge.org)
+* A simple user management/permissions system
+* Support for Markdown and Textile as well as traditional HTML (it's easy to
+  create other filters)
+* An advanced plugin system
+* Operates in two modes: dev and production depending on the URL
+* A caching system which expires pages every 5 minutes
+* Built using Ruby on Rails
+* And much more...
+
+License
+====
+
+Kajam is released under the MIT license and is copyright (c) 2006-2009
+Reset Technology Incorporated . A copy of the MIT license can be found in the
+LICENSE file.
+
+Installation and Setup
+====
+
+Kajam is a traditional Ruby on Rails application, meaning that you can
+configure and run it the way you would a normal Rails application.
+
+See the INSTALL file for more details.
+
+== Installation of a Prerelease
+
+As Kajam nears newer releases, you can experiment with any prerelease version.
+
+Install the prerelease gem with the following command:
+
+    $ gem install kajam --prerelease
+
+This will install the gem with the prerelease name, for example: ‘kajam-0.9.0.rc2’.
+
+== Upgrading an Existing Project to a newer version
+
+1. Update the Kajam assets from in your project:
+
+    $ rake kajam:update
+
+2. Migrate the database:
+
+    $ rake production db:migrate
+
+3. Restart the web server
+
+== Development Requirements
+
+To run tests you will need to have the following gems installed:
+
+  gem install ZenTest rspec rspec-rails cucumber webrat nokogiri
+
+
+Support
+====
+All of our support relies on mailing list:
+
+kajam-contentms@rubyforge.org
+
+Kajam on Github:
+
+http://github.com/ResetTechnlogyInc/kajam
+
+The project wiki is here:
+
+http://wiki.github.com/ResetTechnologyInc/kajam/
+
+Enjoy yor meal!
+
+--
+The ResetTech Dev Team
+http://www.resettek.com/kajamcms

data/Rakefile

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), 'config', 'boot')
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'
+
+unless Rake::Task.task_defined? "kajam:release"
+  Dir["#{KAJAM_ROOT}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+end

data/app/controllers/admin/configuration_controller.rb

@@ -0,0 +1,50 @@
+class Admin::ConfigurationController < ApplicationController
+
+  # Admin::ConfigurationController handles the batch-updating of Kajam::Config entries.
+  # It accepts any set of config name-value pairs but is accessible only to administrators.
+  # Note that configuration is routed as a singular resource so we only deal with show/edit/update
+  # and the show and edit views determine what set of config values is shown and made editable.
+  
+  before_filter :initialize_config
+  
+  only_allow_access_to :edit, :update,
+    :when => [:admin],
+    :denied_url => { :controller => 'admin/configuration', :action => 'show' },
+    :denied_message => 'You must have admin privileges to edit site configuration.'
+
+  def show
+    @user = current_user
+    render
+  end
+  
+  def edit
+    render
+  end
+  
+  def update
+    if params[:config]
+      begin
+        Kajam.config.transaction do
+          params["config"].each_pair do |key, value|
+            @config[key] = Kajam::Config.find_or_create_by_key(key)
+            @config[key].value = value      # validation sets errors on @config['key'] that the helper methods will pick up
+          end
+          redirect_to :action => :show
+        end
+      rescue ActiveRecord::RecordInvalid => e
+        flash[:error] = "Configuration error: please check the form"
+        render :action => :edit
+      rescue Kajam::Config::ConfigError => e
+        flash[:error] = "Configuration error: #{e}"
+        render :action => :edit
+      end
+    end
+  end
+  
+protected
+
+  def initialize_config
+    @config = {}
+  end
+  
+end

data/app/controllers/admin/extensions_controller.rb

@@ -0,0 +1,11 @@
+class Admin::ExtensionsController < ApplicationController
+  only_allow_access_to :index,
+    :when => :admin,
+    :denied_url => { :controller => 'pages', :action => 'index' },
+    :denied_message => 'You must have administrative privileges to perform this action.'
+    
+  def index
+    @template_name = 'index' # for Admin::RegionsHelper
+    @extensions = Kajam::Extension.descendants.sort_by { |e| e.extension_name }
+  end
+end

data/app/controllers/admin/layouts_controller.rb

@@ -0,0 +1,8 @@
+class Admin::LayoutsController < Admin::ResourceController
+  paginate_models
+  only_allow_access_to :index, :show, :new, :create, :edit, :update, :remove, :destroy,
+    :when => [:designer, :admin],
+    :denied_url => { :controller => 'admin/pages', :action => 'index' },
+    :denied_message => 'You must have designer privileges to perform this action.'
+
+end

data/app/controllers/admin/page_fields_controller.rb

@@ -0,0 +1,9 @@
+class Admin::PageFieldsController < Admin::ResourceController
+  def create
+    self.model = PageField.new(params[model_symbol])
+    @controller_name = 'page'
+    @template_name = 'edit'
+    render :partial => "page_field", :object => model,
+      :locals => { :page_field_counter => params[:page_field_counter].to_i}
+  end
+end

data/app/controllers/admin/page_parts_controller.rb

@@ -0,0 +1,9 @@
+class Admin::PagePartsController < Admin::ResourceController
+  def create
+    self.model.attributes = params[model_symbol]
+    @controller_name = 'page'
+    @template_name = 'edit'
+    render :partial => "page_part", :object => model,
+      :locals => {:page_part_counter => params[:index].to_i}
+  end
+end

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,79 @@
+class Admin::PagesController < Admin::ResourceController
+  before_filter :initialize_meta_rows_and_buttons, :only => [:new, :edit, :create, :update]
+  before_filter :count_deleted_pages, :only => [:destroy]
+
+  responses do |r|
+    r.plural.js do
+      @level = params[:level].to_i
+      @template_name = 'index'
+      self.models = Page.find(params[:page_id]).children.all
+      response.headers['Content-Type'] = 'text/html;charset=utf-8'
+      render :action => 'children.html.haml', :layout => false
+    end
+  end
+
+  def index
+    @homepage = Page.find_by_parent_id(nil)
+    response_for :plural
+  end
+
+  def new
+    @page = self.model = model_class.new_with_defaults(config)
+    assign_page_attributes
+    response_for :new
+  end
+  
+  def preview
+    render_preview
+  rescue => exception
+    render :text => exception.message unless @performed_render
+  end
+
+  private
+    def assign_page_attributes
+      if params[:page_id].blank?
+        self.model.slug = '/'
+      end
+      self.model.parent_id = params[:page_id]
+    end
+
+    def model_class
+      if Page.descendants.any? { |d| d.to_s == params[:page_class] }
+        params[:page_class].constantize
+      elsif params[:page_id]
+        Page.find(params[:page_id]).children
+      else
+        Page
+      end
+    end
+      
+    def render_preview
+      Page.transaction do
+        PagePart.transaction do
+          page_class = Page.descendants.include?(model_class) ? model_class : Page
+          if request.referer =~ %r{/admin/pages/(\d+)/edit}
+            page = Page.find($1).becomes(page_class)
+            page.update_attributes(params[:page])
+          else
+            page = page_class.new(params[:page])
+            page.published_at = page.updated_at = page.created_at = Time.now
+            page.parent = Page.find($1) if request.referer =~ %r{/admin/pages/(\d+)/children/new}
+          end
+          page.process(request,response)
+          @performed_render = true
+          raise 'Changes not saved!'
+        end
+      end
+    end
+
+    def count_deleted_pages
+      @count = model.children.count + 1
+    end
+
+    def initialize_meta_rows_and_buttons
+      @buttons_partials ||= []
+      @meta ||= []
+      @meta << {:field => "slug", :type => "text_field", :args => [{:class => 'textbox', :maxlength => 100}]}
+      @meta << {:field => "breadcrumb", :type => "text_field", :args => [{:class => 'textbox', :maxlength => 160}]}
+    end
+end

data/app/controllers/admin/preferences_controller.rb

@@ -0,0 +1,46 @@
+class Admin::PreferencesController < ApplicationController
+  before_filter :load_user
+
+  def initialize
+    @controller_name = 'user'
+    @template_name = 'preferences'
+  end
+
+  def show
+    set_standard_body_style
+    render :edit
+  end
+
+  def edit
+    render
+  end
+
+  def update
+    if valid_params?
+      if @user.update_attributes(params[:user])
+        redirect_to admin_configuration_path
+      else
+        flash[:error] = t('preferences_controller.error_updating')
+        render :edit
+      end
+    else
+      announce_bad_data
+      render :edit
+    end
+  end
+
+  private
+
+  def load_user
+    @user = current_user
+  end
+
+  def valid_params?
+    hash = (params[:user] || {}).symbolize_keys
+    (hash.keys - User.unprotected_attributes).size == 0
+  end
+
+  def announce_bad_data
+    flash[:error] = 'Bad form data.'
+  end
+end

data/app/controllers/admin/references_controller.rb

@@ -0,0 +1,7 @@
+class Admin::ReferencesController < ApplicationController
+  def show
+    respond_to do |format|
+      format.any { render :action => params[:type], :content_type => "text/html", :layout => false }
+    end
+  end
+end

data/app/controllers/admin/resource_controller.rb

@@ -0,0 +1,242 @@
+require 'will_paginate'
+class Admin::ResourceController < ApplicationController
+  extend Kajam::ResourceResponses
+  
+  helper_method :model, :current_object, :models, :current_objects, :model_symbol, :plural_model_symbol, :model_class, :model_name, :plural_model_name
+  before_filter :populate_format
+  before_filter :never_cache
+  before_filter :load_models, :only => :index
+  before_filter :load_model, :only => [:new, :create, :edit, :update, :remove, :destroy]
+  after_filter :clear_model_cache, :only => [:create, :update, :destroy]
+
+  cattr_reader :paginated
+  cattr_accessor :default_per_page, :will_paginate_options
+  
+  responses do |r|
+    # Equivalent respond_to block for :plural responses:
+    # respond_to do |wants|
+    #   wants.xml { render :xml => models }
+    #   wants.json { render :json => models }
+    #   wants.any
+    # end
+    r.plural.publish(:xml, :json) { render format_symbol => models }
+
+    r.singular.publish(:xml, :json) { render format_symbol => model }
+    r.singular.default { redirect_to edit_model_path if action_name == "show" }
+    
+    r.not_found.publish(:xml, :json) { head :not_found }
+    r.not_found.default { announce_not_found; redirect_to :action => "index" }
+
+    r.invalid.publish(:xml, :json) { render format_symbol => model.errors, :status => :unprocessable_entity }
+    r.invalid.default { announce_validation_errors; render :action => template_name }
+
+    r.stale.publish(:xml, :json) { head :conflict }
+    r.stale.default { announce_update_conflict; render :action => template_name }
+
+    r.create.publish(:xml, :json) { render format_symbol => model, :status => :created, :location => url_for(:format => format_symbol, :id => model) }
+    r.create.default { redirect_to continue_url(params) }
+
+    r.update.publish(:xml, :json) { head :ok }
+    r.update.default { redirect_to continue_url(params) }
+
+    r.destroy.publish(:xml, :json) { head :deleted }
+    r.destroy.default { redirect_to continue_url(params) }
+  end
+
+  def index
+    response_for :plural
+  end
+
+  [:show, :new, :edit, :remove].each do |action|
+    class_eval %{
+      def #{action}                # def show
+        response_for :singular     #   response_for :singular
+      end                          # end
+    }, __FILE__, __LINE__
+  end
+
+  [:create, :update].each do |action|
+    class_eval %{
+      def #{action}                                       # def create
+        model.update_attributes!(params[model_symbol])    #   model.update_attributes!(params[model_symbol])
+        response_for :#{action}                           #   response_for :create
+      end                                                 # end
+    }, __FILE__, __LINE__
+  end
+
+  def destroy
+    model.destroy
+    response_for :destroy
+  end
+  
+  def self.model_class(model_class = nil)
+    @model_class ||= (model_class || self.controller_name).to_s.singularize.camelize.constantize
+  end
+
+  # call paginate_models to declare that will_paginate should be used in the index view
+  # options specified here are accessible in the view by calling will_paginate_options
+  # eg.
+  #
+  # Class MyController < Admin::ResourceController
+  #   paginate_models :per_page => 100
+
+  def self.paginate_models(options={})
+    @@paginated = true
+    @@will_paginate_options = options.slice(:class, :previous_label, :next_label, :inner_window, :outer_window, :separator, :container).merge(:param_name => :p)
+    @@default_per_page = options[:per_page]
+  end
+
+  # returns a hash of options that can be passed to will_paginate
+  # the @pagination_for@ helper method calls @will_paginate_options@ unless other options are supplied.
+  #
+  # pagination_for(@events)
+  
+  def will_paginate_options
+    self.class.will_paginate_options || {}
+  end
+  helper_method :will_paginate_options
+
+  # a convenience method that returns true if paginate_models has been called on this controller class
+  # and can be used to make display decisions in controller and view
+  def paginated?
+    self.class.paginated == true && params[:pp] != 'all'
+  end
+  helper_method :paginated?
+
+  # return a hash of page and per_page that can be used to build a will_paginate collection
+  # the per_page figure can be set in several ways:
+  # request parameter > declared by paginate_models > default set in config entry @admin.pagination.per_page@ > overall default of 50
+  def pagination_parameters
+    {
+      :page => (params[:p] || 1).to_i, 
+      :per_page => (params[:pp] || self.class.default_per_page || Kajam::Config['admin.pagination.per_page'] || 50).to_i
+    }
+  end
+
+  protected
+
+    def rescue_action(exception)
+      case exception
+      when ActiveRecord::RecordInvalid
+        response_for :invalid
+      when ActiveRecord::StaleObjectError
+        response_for :stale
+      when ActiveRecord::RecordNotFound
+        response_for :not_found
+      else
+        super
+      end
+    end
+    
+    def model_class
+      self.class.model_class
+    end
+
+    def model
+      instance_variable_get("@#{model_symbol}") || load_model
+    end
+    alias :current_object :model
+    def model=(object)
+      instance_variable_set("@#{model_symbol}", object)
+    end
+    def load_model
+      self.model = if params[:id]
+        model_class.find(params[:id])
+      else
+        model_class.new
+      end
+    end
+
+    def models
+      instance_variable_get("@#{plural_model_symbol}") || load_models
+    end
+    alias :current_objects :models
+    def models=(objects)
+      instance_variable_set("@#{plural_model_symbol}", objects)
+    end
+    def load_models
+      self.models = paginated? ? model_class.paginate(pagination_parameters) : model_class.all
+    end
+
+    def model_name
+      model_class.name
+    end
+    def plural_model_name
+      model_name.pluralize
+    end
+    alias :models_name :plural_model_name
+
+    def model_symbol
+      model_name.underscore.intern
+    end
+    def plural_model_symbol
+      model_name.pluralize.underscore.intern
+    end
+    alias :models_symbol :plural_model_symbol
+
+    def humanized_model_name
+      t(model_name.underscore.downcase)
+    end
+
+    def continue_url(options)
+      options[:redirect_to] || (params[:continue] ? {:action => 'edit', :id => model.id} : index_page_for_model)
+    end
+    
+    def index_page_for_model
+      parts = {:action => "index"}
+      if paginated? && model && i = model_class.all.index(model)
+        p = (i / pagination_parameters[:per_page].to_i) + 1
+        parts[:p] = p if p && p > 1
+      end
+      parts
+    end
+
+    def edit_model_path
+      method = "edit_admin_#{model_name.underscore}_path"
+      send method.to_sym, params[:id]
+    end
+
+    def announce_validation_errors
+      flash.now[:error] = t("resource_controller.validation_errors")
+    end
+
+    def announce_removed
+      ActiveSupport::Deprecation.warn("announce_removed is no longer encouraged in Kajam 0.9.x.", caller)
+      flash[:notice] = t("resource_controller.removed", :humanized_model_name => humanized_model_name)    
+    end
+    
+    def announce_not_found
+      flash[:notice] = t("resource_controller.not_found", :humanized_model_name => humanized_model_name)    
+    end
+
+    def announce_update_conflict
+      flash.now[:error] =  t("resource_controller.update_conflict", :humanized_model_name => humanized_model_name)  
+    end
+
+    def clear_model_cache
+      Kajam::Cache.clear if defined?(Kajam::Cache)
+    end
+
+    def format_symbol
+      format.to_sym
+    end
+
+    def format
+      params[:format] || 'html'
+    end
+    
+    
+    # I would like to set this to expires_in(1.minute, :private => true) to allow for more fluid navigation
+    # but the annoyance for concurrent authors would be too great.
+    def never_cache
+      expires_now
+    end
+    
+    # Assist with user agents that cause improper content-negotiation
+    # warn "Remove default HTML format, Accept header no longer used. (#{__FILE__}: #{__LINE__})" if Rails.version !~ /^2\.1/
+    def populate_format
+      params[:format] ||= 'html' unless request.xhr?
+    end
+    
+    
+end