humpyard 0.0.1

data/Gemfile

@@ -0,0 +1,28 @@
+source 'http://rubygems.org'
+
+gem "rails",              '>=3.0.0'
+gem 'builder'
+gem 'haml',               '>=3.0.0'
+gem 'compass',            '>=0.10.0'
+gem 'acts_as_tree',       '>=0.1.1'
+gem 'cancan',             '>=1.6.4'
+gem 'globalize3',         '>=0.0.7'
+gem 'humpyard_form',      :git => 'http://github.com/humpyard/humpyard_form.git'
+
+group :test do
+  gem 'test-unit'
+  gem 'rspec-rails',        '>=2.0.0.beta.22' 
+  gem 'capybara',           '>=0.3.7' 
+  gem 'database_cleaner',   '>=0.5.2'     
+  gem 'cucumber',           '>=0.8.5' 
+  gem 'cucumber-rails',     '>=0.3.2'
+  gem 'pickle',             '>=0.4.2'
+  gem 'factory_girl',       '>=1.3.2'
+  gem 'markup_validity',    '>=1.1.0'
+  gem 'sqlite3-ruby',       :require => 'sqlite3'
+  gem 'thin'
+end
+
+if RUBY_VERSION < '1.9'
+  gem 'ruby-debug',         '>=0.10.3'
+end

data/README.rdoc

@@ -0,0 +1,61 @@
+= humpyard
+
+Humpyard is a CMS in a gem for Rails 3.
+
+== Installation
+
+* Add Humpyard to your Rails application's Gemfile. It does require edge rails at the moment.
+    gem "rails",         '>=3.0.0'
+    gem 'builder'
+    gem 'haml',          '>=3.0.0'
+    gem 'compass',       '>=0.10.0'
+    gem 'acts_as_tree',  '>=0.1.1'
+    gem 'cancan',        '>=1.3.4'
+    gem 'globalize3',    '>=0.0.7'
+    gem 'humpyard_form', '>=0.0.4'
+    gem 'humpyard',      :git => 'git://github.com/humpyard/humpyard.git'
+    
+* If you want to use textil syntax on TextElements also add RedCloth to the Gemfile.
+    gem 'RedCloth',      '>=4.2.3'
+  
+* Change into your Rails application's directory
+
+* Generate Humpyard skeleton
+    rails generate humpyard:skeleton
+  A full documentation of options for creating a humpyard skeleton can be
+  found at the Humpyard::Generators::ElementGenerator section of this documentation.
+
+* Use an Auth Framework
+
+    rails generate humpyard:auth
+  At the moment there is only a fake user framework for toggling if the admin-user
+  is logged in or not. There are going to be generators for both, Authlogic and Devise,
+  as soon as we get those to work with edge Rails.
+  
+  As the abilities in Humpyard are defined by CanCan, it should be possible to use any
+  auth framework to authentice your users.
+
+* Migrate the Humpyard database tables
+    rake humpyard:db:migrate
+    
+* Create an initial root page (recommended)
+    rake humpyard:pages:create_root
+
+== API Documentation
+
+* API Documentation can be created by running 
+    rake rdoc
+  from the humpyard project directory.
+* There is an auto-generated, up-to-the-hour online_documentation[http://humpyard.org/rdoc] of the API Documentation.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. No discussion. No tests, no game. We use rspec and cucumber with associated addons.
+* Commit, do not mess with rakefile, version, or history. If you want to have your own version, thats fine. But bump your version in a seperate commit that can be ignored when pulling.
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Sven G. Brönstrup. See LICENSE for details.

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/app/controllers/humpyard/assets_controller.rb

@@ -0,0 +1,123 @@
+module Humpyard
+  class AssetsController < ::ApplicationController
+    def index
+      @assets = Humpyard::Asset.all
+      
+      render :partial => 'index'
+    end
+    
+    def new     
+      @asset = Humpyard::config.asset_types[params[:type]].new()
+      
+      authorize! :create, @asset.asset 
+      
+      @asset_type = params[:type]
+      
+      render :partial => 'edit'
+    end
+    
+    def create  
+      @asset = Humpyard::config.asset_types[params[:type]].new params[:asset]
+            
+      unless can? :create, @asset.asset
+        render :json => {
+          :status => :failed
+        }, :status => 403
+        return
+      end
+          
+      if @asset.save
+        @assets = Humpyard::Asset.all
+        render :json => {
+          :status => :ok,
+          :replace => [{
+            :element => "hy-asset-listview",
+            :content => render_to_string(:partial => "list.html", :locals => {:assets => @assets, :asset => @asset})
+          }],
+          :flash => {
+            :level => 'info',
+            :content => I18n.t('humpyard_form.flashes.create_success', :model => Humpyard::Asset.model_name.human)
+          }
+        }
+      else
+        render :json => {
+          :status => :failed, 
+          :errors => @asset.errors,
+          :flash => {
+            :level => 'error',
+            :content => I18n.t('humpyard_form.flashes.create_fail', :model => Humpyard::Asset.model_name.human)
+          }
+        }
+      end
+    end
+    
+    def edit
+      @asset = Humpyard::Asset.find(params[:id]).content_data
+      
+      authorize! :update, @asset.asset
+      
+      render :partial => 'edit'
+    end
+    
+    def update
+      @asset = Humpyard::Asset.find(params[:id])
+      if @asset 
+        unless can? :update, @asset
+          render :json => {
+            :status => :failed
+          }, :status => 403
+          return
+        end
+
+        if @asset.content_data.update_attributes params[:asset]
+          render :json => {
+            :status => :ok,
+            :replace => [
+              { 
+                :element => "hy-asset-listview-text-#{@asset.id}",
+                :content => render_to_string(:partial =>'list_item.html', :locals => {:asset => @asset, :active => true})
+              }
+            ],
+            :flash => {
+              :level => 'info',
+              :content => I18n.t('humpyard_form.flashes.update_success', :model => Humpyard::Asset.model_name.human)
+            }
+          }
+        else
+          render :json => {
+            :status => :failed, 
+            :errors => @asset.content_data.errors,
+            :flash => {
+              :level => 'error',
+              :content => I18n.t('humpyard_form.flashes.update_fail', :model => Humpyard::Asset.model_name.human)
+            }
+          }
+        end
+      else
+        render :json => {
+          :status => :failed,
+          :flash => {
+            :level => 'error',
+            :content => I18n.t('humpyard_form.flashes.not_found', :model => Humpyard::Asset.model_name.human)
+          }
+        }, :status => 404
+      end
+    end
+    
+    def show
+      @asset = Humpyard::Asset.find(params[:id]).content_data
+      
+      authorize! :show, @asset.asset
+      
+      render :partial => 'show'
+    end
+    
+    def destroy
+      @asset = Humpyard::Asset.find(params[:id])
+      
+      authorize! :destroy, @asset  
+      
+      @asset.destroy
+    end
+  end
+end

data/app/controllers/humpyard/elements_controller.rb

@@ -0,0 +1,200 @@
+module Humpyard
+  ####
+  # Humpyard::ElementController is the controller for editing your elements
+  class ElementsController < ::ApplicationController
+    
+    # Dialog content for a new element
+    def new
+      @element = Humpyard::config.element_types[params[:type]].new(
+        :page_id => params[:page_id], 
+        :container_id => params[:container_id].to_i > 0 ? params[:container_id].to_i : nil,
+        :page_yield_name => params[:yield_name].blank? ? 'main' : params[:yield_name],
+        :shared_state => 0)
+      
+      authorize! :create, @element.element 
+      
+      @element_type = params[:type]
+      @prev = Humpyard::Element.find_by_id(params[:prev_id])
+      @next = Humpyard::Element.find_by_id(params[:next_id])
+      
+      render :partial => 'edit'
+    end
+    
+    # Create a new element
+    def create
+      @element = Humpyard::config.element_types[params[:type]].new params[:element]
+            
+      unless can? :create, @element.element
+        render :json => {
+          :status => :failed
+        }, :status => 403
+        return
+      end      
+            
+      if @element.save
+        @prev = Humpyard::Element.find_by_id(params[:prev_id])
+        @next = Humpyard::Element.find_by_id(params[:next_id])
+        
+        do_move(@element, @prev, @next)
+      
+        insert_options = {
+          :element => "hy-id-#{@element.element.id}",
+          :url => humpyard_element_path(@element.element),
+          :parent => @element.container ? "hy-id-#{@element.container.id}" : "hy-content-#{@element.page_yield_name}"
+        }
+        
+        insert_options[:before] = "hy-id-#{@next.id}" if @next
+        insert_options[:after] = "hy-id-#{@prev.id}" if not @next and @prev
+      
+        render :json => {
+          :status => :ok,
+          :dialog => :close,
+          :insert => [insert_options]
+        }
+      else
+        render :json => {
+          :status => :failed, 
+          :errors => @element.errors
+        }
+      end
+    end
+    
+    # Inline edit content for an existing element
+    def inline_edit
+      @element = Humpyard::Element.find(params[:id]).content_data
+      
+      authorize! :update, @element.element
+      
+      render :partial => 'inline_edit'
+    end
+
+    # Dialog content for an existing element
+    def edit
+      @element = Humpyard::Element.find(params[:id]).content_data
+      
+      authorize! :update, @element.element
+      
+      render :partial => 'edit'
+    end
+    
+    # Update an existing element
+    def update
+      @element = Humpyard::Element.find(params[:id])
+      if @element
+        unless can? :update, @element
+          render :json => {
+            :status => :failed
+          }, :status => 403
+          return
+        end
+        
+        if @element.content_data.update_attributes params[:element]
+          render :json => {
+            :status => :ok,
+            :dialog => :close,
+            :replace => [
+              { 
+                :element => "hy-id-#{@element.id}",
+                :url => humpyard_element_path(@element)
+              }
+            ]
+          }
+        else
+          render :json => {
+            :status => :failed, 
+            :errors => @element.content_data.errors
+          }
+        end
+      else
+        render :json => {
+          :status => :failed
+        }, :status => 404
+      end
+    end
+    
+    # Move an element
+    def move
+      @element = Humpyard::Element.find(params[:id])
+      
+      if @element
+        unless can? :update, @element
+          render :json => {
+            :status => :failed
+          }, :status => 403
+          return
+        end
+        
+        @element.update_attributes(
+          :container => Humpyard::Element.find_by_id(params[:container_id]), 
+          :page_yield_name => params[:yield_name]
+        )
+        @prev = Humpyard::Element.find_by_id(params[:prev_id])
+        @next = Humpyard::Element.find_by_id(params[:next_id])
+        
+        do_move(@element, @prev, @next)
+        
+        render :json => {
+          :status => :ok
+        }
+      else
+        render :json => {
+          :status => :failed
+        }, :status => 404        
+      end
+    end
+    
+    # Destroy an element
+    def destroy      
+      @element = Humpyard::Element.find_by_id(params[:id])
+      
+      if can? :destroy, @element  
+        @element.destroy
+      else
+        @error = "You have no permission to delete this element (id: #{@element.class}:#{params[:id]})"
+        render :error
+      end
+    end
+        
+    # Render a given element
+    def show
+      @element = Humpyard::Element.find(params[:id])
+      
+      authorize! :read, @element  
+      
+      render :partial => 'show', :locals => {:element => @element}
+    end
+    
+    private
+    def do_move(element, prev_element, next_element) #:nodoc#
+      if element.container
+        neighbours = element.container.elements
+      else
+        neighbours = element.page.root_elements(element.page_yield_name)
+      end
+      
+      #p "before #{next_id} and after #{prev_id}"
+      p "page_yield: #{element.page_yield_name}"
+
+      position = 0
+      neighbours.each do |el|    
+        if next_element == el
+          p "insert element #{element.id} before #{el.id}"
+          element.update_attribute :position, position
+          position += 1
+        end  
+        if element != el
+          p "process #{el.id} to position #{position}"
+          el.update_attribute :position, position unless element.position == position 
+        end
+        if not next_element and prev_element == el
+          p "insert element #{element.id} after #{el.id}"
+          position += 1
+          element.update_attribute :position, position
+        end
+        if element != el
+          position += 1
+        end
+      end
+    end  
+  end
+end

data/app/controllers/humpyard/errors_controller.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+class Humpyard::ErrorsController < ApplicationController
+  helper 'humpyard::pages'
+  
+  def error404
+    raise ActionController::RoutingError, "No route matches \"#{request.path}\""
+  end
+end

data/app/controllers/humpyard/pages_controller.rb

@@ -0,0 +1,365 @@
+module Humpyard
+  ####
+  # Humpyard::PagesController is the controller for editing and viewing pages
+  class PagesController < ::ApplicationController 
+    helper 'humpyard::pages'
+    
+    # Probably unneccassary - may be removed later
+    def index
+      authorize! :manage, Humpyard::Page  
+      
+      @root_page = Humpyard::Page.root
+      @page = Humpyard::Page.find_by_id(params[:actual_page_id])
+     
+      unless @page.nil?
+        @page = @page.content_data
+      end
+      render :partial => 'index'
+    end
+
+    # Dialog content for a new page
+    def new
+      @page = Humpyard::config.page_types[params[:type]].new
+      
+      unless can? :create, @page.page
+        render :json => {
+          :status => :failed
+        }, :status => 403
+        return
+      end
+      
+      @page_type = params[:type]
+      @prev = Humpyard::Page.find_by_id(params[:prev_id])
+      @next = Humpyard::Page.find_by_id(params[:next_id])
+      
+      render :partial => 'edit'
+    end
+    
+    # Create a new page
+    def create
+      @page = Humpyard::config.page_types[params[:type]].new params[:page]
+      @page.title_for_url = @page.page.suggested_title_for_url
+      
+      authorize! :create, @page.page
+      
+      if @page.save
+        @prev = Humpyard::Page.find_by_id(params[:prev_id])
+        @next = Humpyard::Page.find_by_id(params[:next_id])
+        
+        #do_move(@page, @prev, @next)
+      
+        # insert_options = {
+        #   :element => "hy-id-#{@page.id}",
+        #   :url => @page.page.human_url,
+        #   :parent => @page.parent ? "hy-page-dialog-item-#{@page.id}" : "hy-page-dialog-pages"
+        # }
+        
+        # insert_options[:before] = "hy-page-dialog-item-#{@next.id}" if @next
+        # insert_options[:after] = "hy-page-dialog-item-#{@prev.id}" if not @next and @prev
+
+        # just reload the tree
+      
+        replace_options = {
+          :element => "hy-page-treeview",
+          :content => render_to_string(:partial => "tree.html", :locals => {:page => @page})
+        }
+      
+        render :json => {
+          :status => :ok,
+          #:dialog => :close,
+          # :insert => [insert_options],
+          :replace => [replace_options],
+          :flash => {
+            :level => 'info',
+            :content => I18n.t('humpyard_form.flashes.create_success', :model => Humpyard::Page.model_name.human)
+          }
+        }
+      else
+        render :json => {
+          :status => :failed, 
+          :errors => @page.errors,
+          :flash => {
+            :level => 'error',
+            :content => I18n.t('humpyard_form.flashes.create_fail', :model => Humpyard::Page.model_name.human)
+          }
+        }
+      end
+    end
+    
+    # Dialog content for an existing page
+    def edit
+      @page = Humpyard::Page.find(params[:id]).content_data
+      
+      authorize! :update, @page.page
+      
+      render :partial => 'edit'
+    end
+    
+    # Update an existing page
+    def update
+      @page = Humpyard::Page.find(params[:id]).content_data
+      
+      if @page 
+        unless can? :update, @page.page
+          render :json => {
+            :status => :failed
+          }, :status => 403
+          return
+        end
+        
+        if @page.update_attributes params[:page]
+          @page.title_for_url = @page.page.suggested_title_for_url
+          @page.save
+          render :json => {
+            :status => :ok,
+#            :dialog => :close,
+            :replace => [
+              { 
+                :element => "hy-page-treeview-text-#{@page.id}",
+                :content => @page.title
+              }
+            ],
+            :flash => {
+              :level => 'info',
+              :content => I18n.t('humpyard_form.flashes.update_success', :model => Humpyard::Page.model_name.human)
+            }
+          }
+        else
+          render :json => {
+            :status => :failed, 
+            :errors => @page.errors,
+            :flash => {
+              :level => 'error',
+              :content => I18n.t('humpyard_form.flashes.update_fail', :model => Humpyard::Page.model_name.human)
+            }
+          }
+        end
+      else
+        render :json => {
+          :status => :failed
+        }, :status => 404
+      end
+      
+    end
+    
+    # Move a page
+    def move
+      @page = Humpyard::Page.find(params[:id])
+      
+      if @page 
+        unless can? :update, @page
+          render :json => {
+            :status => :failed
+          }, :status => 403
+          return
+        end
+        
+        parent = Humpyard::Page.find_by_id(params[:parent_id])
+        # by default, make it possible to move page to root, uncomment to do otherwise:
+        #unless parent
+        #  parent = Humpyard::Page.root_page
+        #end
+        @page.update_attribute :parent, parent
+        @prev = Humpyard::Page.find_by_id(params[:prev_id])
+        @next = Humpyard::Page.find_by_id(params[:next_id])
+        
+        do_move(@page, @prev, @next)
+        
+        replace_options = {
+          :element => "hy-page-treeview",
+          :content => render_to_string(:partial => "tree.html", :locals => {:page => @page})
+        }
+        
+        render :json => {
+          :status => :ok,
+          :replace => [replace_options]
+        }
+      else
+        render :json => {
+          :status => :failed
+        }, :status => 404        
+      end
+    end
+    
+    # Destroy a page
+    def destroy
+      @page = Humpyard::Page.find(params[:id])
+      
+      authorize! :destroy, @page  
+      
+      @page.destroy
+    end
+
+    
+    # Render a given page
+    # 
+    # When a "webpath" parameter is given it will render the page with that name.
+    # This is what happens when you call a page with it's pretty URL.
+    #
+    # When no "name" is given and an "id" parameter is given it will render the
+    # page with the given id.
+    #
+    # When no "name" nor "id" parameter is given it will render the root page.
+    def show
+      # No page found at the beginning
+      @page = nil
+
+      if params[:locale] and Humpyard.config.locales.include? params[:locale].to_sym
+        I18n.locale = params[:locale]
+      elsif session[:humpyard_locale]
+        I18n.locale = session[:humpyard_locale]
+      else
+        I18n.locale = Humpyard.config.locales.first
+      end
+      
+      # Find page by name
+      if not params[:webpath].blank?
+        dyn_page_path = false
+        parent_page = nil
+        params[:webpath].split('/').each do |path_part|
+          # Ignore multiple slashes in URLs
+          unless(path_part.blank?)
+            if(dyn_page_path) 
+              dyn_page_path << path_part
+            else     
+              # Find page by name and parent; parent=nil means page on root level
+              @page = Page.with_translated_attribute(:title_for_url, CGI::escape(path_part), I18n.locale).first
+              # Raise 404 if no page was found for the URL or subpart
+              raise ::ActionController::RoutingError, "No route matches \"#{request.path}\" (X4201) [#{path_part}]" if @page.nil?
+              raise ::ActionController::RoutingError, "No route matches \"#{request.path}\" (X4202)" if not (@page.parent == parent_page or @page.parent == Humpyard::Page.root_page)
+              
+              parent_page = @page unless @page.is_root_page?
+              dyn_page_path = [] if @page.content_data.is_humpyard_dynamic_page? 
+            end
+          end
+        end
+
+        if @page.content_data.is_humpyard_dynamic_page? and dyn_page_path.size > 0
+          @sub_page = @page.parse_path(dyn_page_path)
+          
+          # Raise 404 if no page was found for the sub_page part
+          raise ::ActionController::RoutingError, "No route matches \"#{request.path}\" (D4201)" if @sub_page.blank?
+
+          @page_partial = "/humpyard/pages/#{@page.content_data_type.split('::').last.underscore.pluralize}/#{@sub_page[:partial]}" if @sub_page[:partial]
+          @local_vars = {:page => @page}.merge(@sub_page[:locals]) if @sub_page[:locals] and @sub_page[:locals].class == Hash
+          
+          # render partial only if request was an AJAX-call
+          if request.xhr?
+            respond_to do |format|
+              format.html {
+                render :partial => @page_partial, :locals => @local_vars
+              }
+            end
+            return
+          end
+        end
+        
+      # Find page by id
+      elsif not params[:id].blank?
+        # Render page by id if not webpath was given but an id
+        @page = Page.find(params[:id])
+      # Find root page
+      else
+        # Render index page if neither id or webpath was given
+        @page = Page.root_page :force_reload => true
+        unless @page
+          @page = Page.new
+          render '/humpyard/pages/welcome'
+          return false
+        end
+      end
+      
+      # Raise 404 if no page was found
+      raise ::ActionController::RoutingError, "No route matches \"#{request.path}\"" if @page.nil? or @page.content_data.is_humpyard_virtual_page?
+      
+      response.headers['X-Humpyard-Page'] = "#{@page.id}"
+      response.headers['X-Humpyard-Modified'] = "#{@page.last_modified}"
+      response.headers['X-Humpyard-ServerTime'] = "#{Time.now.utc}"
+ 
+      @page_partial ||= "/humpyard/pages/#{@page.content_data_type.split('::').last.underscore.pluralize}/show"
+      @local_vars ||= {:page => @page}
+
+      self.class.layout(@page.template_name)
+
+      if Rails.application.config.action_controller.perform_caching and not @page.always_refresh
+        fresh_when :etag => "#{humpyard_user.nil? ? '' : humpyard_user}p#{@page.id}m#{@page.last_modified}", :last_modified => @page.last_modified(:include_pages => true), :public => @humpyard_user.nil?
+      end
+    end
+    
+    # Render the sitemap.xml for robots
+    def sitemap
+      require 'builder'
+      
+      xml = ::Builder::XmlMarkup.new :indent => 2
+      xml.instruct!
+      xml.tag! :urlset, {
+        'xmlns'=>"http://www.sitemaps.org/schemas/sitemap/0.9",
+        'xmlns:xsi'=>"http://www.w3.org/2001/XMLSchema-instance",
+        'xsi:schemaLocation'=>"http://www.sitemaps.org/schemas/sitemap/0.9\nhttp://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
+      } do
+
+        base_url = "#{request.protocol}#{request.host}#{request.port==80 ? '' : ":#{request.port}"}"
+
+        if root_page = Page.root_page
+          Humpyard.config.locales.each do |locale|
+            add_to_sitemap xml, base_url, locale, [{
+                :index => true,
+                :url => root_page.human_url(:locale => locale),
+                :lastmod => root_page.last_modified,
+                :children => []
+              }] + root_page.child_pages(:single_root => true).map{|p| p.content_data.site_map(locale)}
+          end
+        end
+      end
+      render :xml => xml.target!
+    end
+
+    private
+    def add_to_sitemap xml, base_url, locale, pages, priority=0.8, changefreq='daily' 
+      pages.each do |page|
+        if page
+          unless page[:hidden]
+            xml.tag! :url do
+              xml.tag! :loc, "#{base_url}#{page[:url]}"
+              xml.tag! :lastmod, page[:lastmod].nil? ? nil : page[:lastmod].to_time.strftime("%FT%T%z").gsub(/00$/,':00')
+              xml.tag! :changefreq, page[:changefreq] ? page[:changefreq] : changefreq
+              xml.tag! :priority, page[:index] ? 1.0 : priority
+            end
+          end
+          add_to_sitemap xml, base_url, locale, page[:children], priority/2
+        end
+      end
+    end
+    
+    def do_move(page, prev_page, next_page) #:nodoc#
+      if page.parent
+        neighbours = page.parent.child_pages
+      else
+        neighbours = Humpyard::Page.where('parent_id IS NULL')
+      end
+
+      #p "before #{next_id} and after #{prev_id}"
+
+      position = 0
+      neighbours.each do |p|    
+        if next_page == p
+          puts "insert page #{page.id} before #{p.id}"
+          page.update_attribute :position, position
+          position += 1
+        end  
+        if page != p
+          puts "process page #{p.id} to position #{position}"
+          p.update_attribute :position, position 
+        end
+        if not next_page and prev_page == p
+          puts "insert page #{page.id} after #{p.id}"
+          position += 1
+          page.update_attribute :position, position
+        end
+        if page != p
+          position += 1
+        end
+      end
+    end  
+  end
+end