deluxe_publisher 0.0.3

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+-
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,29 @@
+source "http://rubygems.org"
+
+gem "rails", ">= 3.0.5"
+gem "capybara", ">= 0.4.0"
+gem "webrat"
+gem "sqlite3"
+
+#gem 'ckeditor', :git => 'git://github.com/galetahub/rails-ckeditor.git', :branch => 'rails3'
+gem 'ckeditor', '3.5.2'
+gem 'paperclip', "~> 2.3.8"
+gem "haml", "~> 3.0.24"
+gem 'nested_set', '~> 1.6.4'
+gem 'acts-as-taggable-on', "~> 2.0.6"
+
+
+
+
+group :development do
+  gem "rspec-rails", "~> 2.6.0"
+  gem "autotest", "~> 4.4.6"
+  gem 'factory_girl_rails', "~> 1.0.1"
+  gem 'jquery-rails', "~> 0.2.7"
+  gem 'jeweler', '~> 1.5.2'
+end
+# To use debugger (ruby-debug for Ruby 1.8.7+, ruby-debug19 for Ruby 1.9.2+)
+# gem 'ruby-debug'
+# gem 'ruby-debug19'
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Paul Raupach
+
+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.rdoc

@@ -0,0 +1,127 @@
+= DeluxePublisher
+
+Deluxe Publisher Content Managament Sytem (CMS) Gem was created to easily allow the addition of a CMS to a Rails website
+so that clients can update their own content pages inlcluding simple blog pages. While an entire website could be
+created with only the Deluxe Publisher its designed to add CMS pages/features to sites that have other more complicated
+features.
+
+Deluxe Publisher is a Rails 3 Engine and therefore requires Rails 3.
+
+<b>Alpha Alpha Alpha</b>, this CMS is under heavy development and not ready for prime time. Use at your own risk.
+
+== Instilation
+
+=== Gemfile
+
+Crate a new rails project, change directory to that project, and don't forget to delete your index.html file.
+
+    rails new MyDeluxeWebsite
+    cd MyDeluxeWebsite
+    rm public/index.html
+
+Or change directory to your rails project.
+
+Add these to your Gem file
+
+    gem "deluxe_publisher", :git => "git://github.com/PaulRaye/Deluxe-Publisher.git"
+    gem "acts-as-taggable-on", "~> 2.0.6"
+    gem "nested_set", "~> 1.6.4"
+    gem "ckeditor", "3.5.2"
+    gem "paperclip", "~> 2.3.8"
+    gem "aws-s3"
+
+and
+    bundle install
+
+=== CKEditor
+
+Deluxe Publisher uses CKEditor as it WYSIWYG edtor for content areas.
+
+    rails g ckeditor:base
+    rails g ckeditor:migration
+    rake db:migrate
+
+See https://github.com/galetahub/rails-ckeditor for details
+
+=== Set up S3
+If you are using S3 for your uploaded images and files set up your S3.yml file and update your Picture and
+AttachmentFile Models
+See https://github.com/galetahub/rails-ckeditor for details
+
+=== Acts as Taggable On
+Deluxe Publisher uses Acts as Taggable On for tags in the blog pages, must be installed even if you are not useing blog
+pages.
+
+    rails g acts_as_taggable_on:migration
+    rake db:migrate
+
+See https://github.com/mbleigh/acts-as-taggable-on for details.
+
+=== Deluxe Publisher
+Now to Deluxe Publisher, we need to generate some javascript, CSS and images for the Content Management System as well
+as example files you can use as a starting point for designing your site.
+
+    rails g deluxe_publisher:base
+
+Generate the migration for the Deluxe Publisher Tables and migrate.
+
+    rails g deluxe_publisher:migration
+    rake db:migrate
+
+=== Load Sample Site
+Now lets load in a sample site so we're not starting with a black page.
+    rails g deluxe_publisher:sample_site
+
+=== Routes
+If you are not using any other engines with your rails application then Deluxe Publisher will use its default routes
+including the wild card route that captures all routes not specified otherwise.  You can add routes to your
+routes.rb file that will take presidence over the Deluxe Publisher Routes.  However if you are using other Rails
+Engines that also have dedault routes you may need to move those engines routes into your /config/routes.rb file to
+ensure they are called before Deluxe Publishers wildcard route.
+
+
+=== Authentication
+
+Deluxe Publisher designed to use your sites authentication, not force one on you.
+
+Authentication is set up by selecting the authentication method for both the public facing pages and
+the Administration tools.  There are three authentication options:
+
+* :none indicating no authentication
+* :basic uses Rails authenticate_or_request_with_http_basic along with login and password you provide
+* :method calls back to an authentication method you provide
+
+The Authentication setting are set in the config/initializers/deluxe_publisher.rb file
+
+  # authentication procedure for public facing pages
+  #use :none, :basic, :method
+  config.publisher_authorization_procedure = :none
+  #for :basic authorization procedure
+  config.publisher_username = "Bob"
+  config.publisher_password = "isyouruncle"
+  #for :method authorization procedure
+  config.publisher_authorization_method = :your_authorization_method
+
+  #Authentication procedure for deluxe publisher admin pages
+  #use :none, :basic, :method
+  config.admin_authorization_procedure = :basic
+  #for :basic authorization procedure
+  config.admin_username = "admin"                             ##########       Please Please Please    ##########
+  config.admin_password = "nimda"                             ##########  Change username and password ##########
+  #for :method authorization procedure                        ##########        Or better yet use      ##########
+  config.admin_authorization_method = :authenticate_admin!    ##########     an Authorization method   ##########
+
+Note that the default authentication for public is :none and the default authentication for publisher is :basic with
+username and password of admin/nimda.  These are intended to be bad so you're forced to change them.
+
+== Its Installed!, now what?
+
+Profit!
+
+Detailed Instructions to come but you can create page types here:
+
+http://yourapp.com/deluxe_publisher/page_types
+
+And you can create pages here:
+
+http://yourapp.com/deluxe_publisher/pages

data/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "deluxe_publisher"
+  gem.homepage = "http://github.com/PaulRaye/deluxe_publisher"
+  gem.license = "MIT"
+  gem.summary = %Q{CMS for Rails 3#}
+  gem.description = %Q{Content Management System for Rails 3 Created by Paul @ Deluxe Digital Media}
+  gem.email = "paul@raupach.com"
+  gem.authors = ["Paul Raupach"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  gem.add_runtime_dependency 'ckeditor', '3.5.2'
+  gem.add_runtime_dependency 'paperclip', "~> 2.3.8"
+  gem.add_runtime_dependency "haml", "~> 3.0.24"
+  gem.add_runtime_dependency 'nested_set', '~> 1.6.4'
+  gem.add_runtime_dependency 'acts-as-taggable-on', "~> 2.0.6"
+
+  #gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "rspec-rails", "~> 2.6.0"
+  gem.add_development_dependency "autotest", "~> 4.4.6"
+  gem.add_development_dependency 'factory_girl_rails', "~> 1.0.1"
+  gem.add_development_dependency 'jquery-rails', "~> 0.2.7"
+  gem.add_development_dependency 'jeweler', '~> 1.5.2'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "deluxe_publisher #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/app/controllers/deluxe_publisher/comments_controller.rb

@@ -0,0 +1,93 @@
+class DeluxePublisher::CommentsController < ApplicationController
+
+  before_filter :load_page
+  layout "deluxe_publisher"
+
+  # GET /deluxe_publisher/comments
+  # GET /deluxe_publisher/comments.xml
+  def index
+    @deluxe_publisher_comments = @page.comments.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @deluxe_publisher_comments }
+    end
+  end
+
+  # GET /deluxe_publisher/comments/1
+  # GET /deluxe_publisher/comments/1.xml
+  def show
+    @deluxe_publisher_comment = @page.comments.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @deluxe_publisher_comment }
+    end
+  end
+
+  # GET /deluxe_publisher/comments/new
+  # GET /deluxe_publisher/comments/new.xml
+  def new
+    @deluxe_publisher_comment = @page.comments.build
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @deluxe_publisher_comment }
+    end
+  end
+
+  # GET /deluxe_publisher/comments/1/edit
+  def edit
+    @deluxe_publisher_comment = DeluxePublisher::Comment.find(params[:id])
+  end
+
+  # POST /deluxe_publisher/comments
+  # POST /deluxe_publisher/comments.xml
+  def create
+    @deluxe_publisher_comment = @page.comments.build(params[:deluxe_publisher_comment])
+
+    respond_to do |format|
+      if @deluxe_publisher_comment.save
+        format.html { redirect_to(deluxe_publisher_page_comments_path(@page), :notice => 'Comment was successfully created.') }
+        format.xml  { render :xml => @deluxe_publisher_comment, :status => :created, :location => @deluxe_publisher_comment }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @deluxe_publisher_comment.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /deluxe_publisher/comments/1
+  # PUT /deluxe_publisher/comments/1.xml
+  def update
+    @deluxe_publisher_comment = @page.comments.find(params[:id])
+
+    respond_to do |format|
+      if @deluxe_publisher_comment.update_attributes(params[:deluxe_publisher_comment])
+        format.html { redirect_to( deluxe_publisher_page_comments_path(@page), :notice => 'Comment was successfully updated.') }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @deluxe_publisher_comment.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /deluxe_publisher/comments/1
+  # DELETE /deluxe_publisher/comments/1.xml
+  def destroy
+    @deluxe_publisher_comment = @page.comments.find(params[:id])
+    @deluxe_publisher_comment.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(deluxe_publisher_page_comments_url(@page)) }
+      format.xml  { head :ok }
+    end
+  end
+
+  private
+
+  def load_page
+    @page = DeluxePublisher::Page.find(params[:page_id])
+  end
+end

data/app/controllers/deluxe_publisher/page_types_controller.rb

@@ -0,0 +1,115 @@
+class DeluxePublisher::PageTypesController < ApplicationController
+
+  include DeluxePublisherAuthentication
+  
+  before_filter :admin_authorize
+  
+  layout "deluxe_publisher"
+
+  # GET /deluxe_publisher/page_types
+  # GET /deluxe_publisher/page_types.xml
+  def index
+    @deluxe_publisher_page_types = DeluxePublisher::PageType.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @deluxe_publisher_page_types }
+    end
+  end
+
+  # GET /deluxe_publisher/page_types/1
+  # GET /deluxe_publisher/page_types/1.xml
+  def show
+    @deluxe_publisher_page_type = DeluxePublisher::PageType.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @deluxe_publisher_page_type }
+    end
+  end
+
+  # GET /deluxe_publisher/page_types/new
+  # GET /deluxe_publisher/page_types/new.xml
+  def new
+    @deluxe_publisher_page_type = DeluxePublisher::PageType.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @deluxe_publisher_page_type }
+    end
+  end
+
+  # GET /deluxe_publisher/page_types/1/edit
+  def edit
+    @deluxe_publisher_page_type = DeluxePublisher::PageType.find(params[:id])
+  end
+
+
+  def content_areas_change
+    if params.has_key?(:id)
+      @deluxe_publisher_page_type = DeluxePublisher::PageType.find(params[:id])
+    else
+      @deluxe_publisher_page_type = DeluxePublisher::PageType.new
+    end
+
+    @deluxe_publisher_page_type.number_of_content_areas = params[:deluxe_publisher_page_type][:number_of_content_areas]
+    stash_descriptor_attributes
+    respond_to do |format|
+      format.js {render :layout => false}
+    end
+  end
+
+  # POST /deluxe_publisher/page_types
+  # POST /deluxe_publisher/page_types.xml
+  def create
+    @deluxe_publisher_page_type = DeluxePublisher::PageType.new(params[:deluxe_publisher_page_type])
+
+    respond_to do |format|
+      if @deluxe_publisher_page_type.save
+        format.html { redirect_to(@deluxe_publisher_page_type, :notice => 'Page type was successfully created.') }
+        format.xml  { render :xml => @deluxe_publisher_page_type, :status => :created, :location => @deluxe_publisher_page_type }
+      else
+        stash_descriptor_attributes
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @deluxe_publisher_page_type.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /deluxe_publisher/page_types/1
+  # PUT /deluxe_publisher/page_types/1.xml
+  def update
+    @deluxe_publisher_page_type = DeluxePublisher::PageType.find(params[:id])
+
+    respond_to do |format|
+      if @deluxe_publisher_page_type.update_attributes(params[:deluxe_publisher_page_type])
+        format.html { redirect_to(@deluxe_publisher_page_type, :notice => 'Page type was successfully updated.') }
+        format.xml  { head :ok }
+      else
+        stash_descriptor_attributes
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @deluxe_publisher_page_type.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /deluxe_publisher/page_types/1
+  # DELETE /deluxe_publisher/page_types/1.xml
+  def destroy
+    @deluxe_publisher_page_type = DeluxePublisher::PageType.find(params[:id])
+    @deluxe_publisher_page_type.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(deluxe_publisher_page_types_url) }
+      format.xml  { head :ok }
+    end
+  end
+
+  private
+
+  def stash_descriptor_attributes
+    unless params[:deluxe_publisher_page_type].nil? || params[:deluxe_publisher_page_type][:content_descriptors_attributes].nil?
+      @deluxe_publisher_page_type.stash_descriptor_attributes(params[:deluxe_publisher_page_type][:content_descriptors_attributes])
+    end
+  end
+end

data/app/controllers/deluxe_publisher/pages_controller.rb

@@ -0,0 +1,191 @@
+class DeluxePublisher::PagesController < ApplicationController
+
+  include DeluxePublisherAuthentication
+
+  layout "deluxe_publisher"
+  before_filter :load_root_page
+
+  before_filter :admin_authorize
+
+  # GET /pages
+  # GET /pages.xml
+  def index
+
+    @pages = @root_page.descendants.find(:all, :include => :page_type)
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @pages }
+    end
+  end
+
+  # GET /pages/1
+  # GET /pages/1.xml
+  def show
+    @page = DeluxePublisher::Page.find(params[:id])
+
+    @root_page = @page.root
+
+    if @page.is_a_blog?
+      @blog = @page
+      @tags = DeluxePublisher::Page.tag_counts_on(:tags)
+    end
+
+    if @page.is_a_blog_story?
+      @blog = @page.parent
+      @tags = DeluxePublisher::Page.tag_counts_on(:tags)
+    end
+
+    respond_to do |format|
+      format.html do
+        if @page.page_type.layout.blank?
+          render :template => "/deluxe_publisher/templates/#{@page.page_type.template}", :layout => false
+        else
+          render :template => "/deluxe_publisher/templates/#{@page.page_type.template}", :layout => @page.page_type.layout
+        end
+      end
+    end
+
+  end
+
+  # GET /pages/new
+  # GET /pages/new.xml
+  def new
+
+
+    if params.has_key?(:copy_id)
+      subject = DeluxePublisher::Page.find(params[:copy_id])
+      @page = subject.clone
+      @page.is_published = false
+      (0..(subject.number_of_contents-1)).each do |position|
+        c = subject.contents[position].clone
+        c.page_id = nil
+        @page.stash_content(position, c)
+      end
+    else
+      @page = DeluxePublisher::Page.new
+    end
+
+    if params.has_key?(:parent_id)
+      @page.parent_id = params[:parent_id]
+    else
+      @page.parent_id = DeluxePublisher::Page.get_site_root(1).id
+    end
+
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @page }
+    end
+  end
+
+  # GET /pages/1/edit
+  def edit
+    @page = DeluxePublisher::Page.find_with_content(params[:id])
+  end
+
+  def page_type_change
+    if params.has_key?(:id)
+      @page = DeluxePublisher::Page.find_with_content(params[:id])
+    else
+      @page = DeluxePublisher::Page.new
+    end
+    page_type = DeluxePublisher::PageType.find(params[:deluxe_publisher_page][:page_type_id])
+    @page.page_type = page_type
+    stash_content
+
+    respond_to do |format|
+      format.js {render :layout => false}
+    end
+
+  end
+
+  # POST /pages
+  # POST /pages.xml
+  def create
+    @page = DeluxePublisher::Page.new(params[:deluxe_publisher_page])
+    @page.site_id = 1
+    respond_to do |format|
+      if @page.save
+        format.html { redirect_to(deluxe_publisher_pages_path, :notice => 'Page was successfully created.') }
+        format.xml  { render :xml => @page, :status => :created, :location => @page }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @page.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /pages/1
+  # PUT /pages/1.xml
+  def update
+    @page = DeluxePublisher::Page.find(params[:id])
+
+    respond_to do |format|
+      if @page.update_attributes(params[:deluxe_publisher_page])
+        format.html { redirect_to(deluxe_publisher_pages_path, :notice => 'Page was successfully updated.') }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @page.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+
+  def preview
+
+
+    params[:deluxe_publisher_page][:contents_attributes].each do |content|
+      content[1]["id"] = nil
+    end
+
+
+    @page = DeluxePublisher::Page.new(params[:deluxe_publisher_page])
+
+    @root_page = @page.root
+
+    if @page.is_a_blog?
+      @blog = @page
+      @tags = DeluxePublisher::Page.tag_counts_on(:tags)
+    end
+
+    if @page.is_a_blog_story?
+      @blog = @page.parent
+      @tags = DeluxePublisher::Page.tag_counts_on(:tags)
+    end
+
+
+    if @page.page_type.layout.blank?
+      render :template => "/deluxe_publisher/templates/#{@page.page_type.template}", :layout => false
+    else
+      render :template => "/deluxe_publisher/templates/#{@page.page_type.template}", :layout => @page.page_type.layout
+    end
+  end
+
+  # DELETE /pages/1
+  # DELETE /pages/1.xml
+  def destroy
+    @page = DeluxePublisher::Page.find(params[:id])
+    @page.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(deluxe_publisher_pages_url) }
+      format.xml  { head :ok }
+    end
+  end
+
+  def load_root_page
+    site_id = 1
+    @root_page = DeluxePublisher::Page.get_site_root(site_id)
+  end
+
+  private
+  def stash_content
+    @page.stash_content_attributes(params[:deluxe_publisher_page][:contents_attributes])
+
+  end
+
+
+end
+