jakewendt-simply_pages 2.0.0

data/generators/simply_pages/templates/javascripts/pages.js

@@ -0,0 +1,48 @@
+var initial_page_order;
+jQuery(function(){
+	jQuery('#pages').sortable({
+		axis:'y', 
+		dropOnEmpty:false, 
+		handle:'img.handle', 
+		update:function(event,ui){compare_page_order()},
+		items:'tr.page.row'
+	});
+
+	jQuery('#save_order').disable();
+
+	initial_page_order = page_order();
+
+	jQuery('form#order_pages').submit(function(){
+		if( initial_page_order == page_order() ) {
+			/*
+				Shouldn't get here as button should 
+				be disabled if not different!
+			*/
+			alert("Page order hasn't changed. Nothing to save.");
+			return false
+		} else {
+			new_action = jQuery(this).attr('action');
+			if( (/\?/).test(new_action) ){
+				new_action += '&';
+			} else {
+				new_action += '?';
+			}
+			new_action += page_order();
+			jQuery(this).attr('action',new_action);
+		}
+	})
+
+});
+
+function page_order() {
+	return jQuery('#pages').sortable('serialize',{key:'pages[]'});
+}
+
+function compare_page_order(){
+	if( initial_page_order == page_order() ) {
+		jQuery('#save_order').disable();
+	} else {
+		jQuery('#save_order').highlight(4000);
+		jQuery('#save_order').enable();
+	}
+}

data/generators/simply_pages/templates/migrations/create_pages.rb

@@ -0,0 +1,26 @@
+class CreatePages < ActiveRecord::Migration
+	def self.up
+		create_table :pages do |t|
+			t.integer :position
+			t.integer :parent_id
+			t.boolean :hide_menu, :default => false
+			t.string :path
+			t.string :title_en
+			t.string :title_es
+			t.string :menu_en
+			t.string :menu_es
+			t.text :body_en
+			t.text :body_es
+			t.timestamps
+		end
+		add_index :pages, :path, :unique => true
+		add_index :pages, :parent_id
+#	acts_as_list doesn't like the uniqueness
+#	when it reorders, positions are temporarily not unique
+#		add_index :pages, :position, :unique => true, :name => 'by_position'
+	end
+
+	def self.down
+		drop_table :pages
+	end
+end

data/generators/simply_pages/templates/models/page.rb

@@ -0,0 +1,107 @@
+#	==	requires
+#	*	path ( unique, > 1 char and starts with a / )
+#	*	menu ( unique and > 3 chars )
+#	*	title ( > 3 chars )
+#	*	body ( > 3 chars )
+#
+#	==	named_scope(s)
+#	*	not_home (returns those pages where path is not just '/')
+#	*	roots
+#
+#	uses acts_as_list for parent / child relationship.  As this
+#	is only a parent and child and no deeper, its ok.  If it
+#	were to get any deeper, the list should probably be changed
+#	to something like a nested set.
+class Page < ActiveRecord::Base
+	default_scope :order => :position
+
+	acts_as_list :scope => :parent_id
+#	acts_as_list :scope => "parent_id \#{(parent_id.nil?)?'IS NULL':'= parent_id'} AND locale = '\#{locale}'"
+
+	validates_presence_of :path
+	validates_length_of :path,  :minimum => 1
+	validates_format_of :path,  :with => /^\//
+#	validates_presence_of :menu_en
+	validates_length_of :menu_en,  :minimum => 4
+#	validates_presence_of :title_en
+	validates_length_of :title_en, :minimum => 4
+#	validates_presence_of :body_en
+	validates_length_of :body_en,  :minimum => 4
+	validates_uniqueness_of :menu_en
+	validates_uniqueness_of :path
+
+	belongs_to :parent, :class_name => 'Page'
+	has_many :children, :class_name => 'Page', :foreign_key => 'parent_id',
+		:dependent => :nullify
+	
+	named_scope :roots, :conditions => { 
+		:parent_id => nil, :hide_menu => false }
+
+	named_scope :hidden, :conditions => { 
+		:hide_menu => true }
+
+	named_scope :not_home, :conditions => [ "path != '/'" ]
+
+	attr_accessible :path, :parent_id, :hide_menu,
+		:menu,  :menu_en,  :menu_es, 
+		:title, :title_en, :title_es,
+		:body,  :body_en,  :body_es
+
+	before_validation :adjust_path
+
+	def to_s
+		title
+	end
+
+	def adjust_path
+		unless self.path.nil?
+			#	remove any duplicate /'s
+#			self.path = path.gsub(/\/+/,'/')
+			self.path.gsub!(/\/+/,'/')
+
+			#	add leading / if none
+#			self.path = path.downcase
+			self.path.downcase!
+		end
+	end
+
+	#	named_scopes ALWAYS return an "Array"
+	#	so if ONLY want one, MUST use a method.
+	#	by_path returns the one(max) page that
+	#	matches the given path.
+	def self.by_path(path)
+		page = find(:first,
+			:conditions => {
+				:path   => path.downcase
+			}
+		)
+	end
+
+	def root
+		page = self
+		until page.parent == nil
+			page = page.parent
+		end 
+		page
+	end
+
+	def is_home?
+		self.path == "/"
+	end
+
+	#	Virtual attributes
+	%w( menu title body ).each do |attr|
+		define_method "#{attr}" do |*args|
+			r = send("#{attr}_#{args[0]||'en'}")
+			(r.blank?) ? send("#{attr}_en") : r
+		end
+		define_method "#{attr}=" do |new_val|
+			self.send("#{attr}_en=",new_val)
+		end
+#		attr_accessible attr.to_sym
+#		%w( en es ).each do |lang|
+#			attr_accessible "#{attr}_#{lang}".to_sym
+#		end
+	end
+
+end

data/generators/simply_pages/templates/models/page_sweeper.rb

@@ -0,0 +1,74 @@
+#	While sweepers are model observers, they only seem
+#	to be so within the scope of a given controller.
+#	If the 'cache_sweeper' line is not given in the 
+#	controller, these observers don't see it.
+#	In addition, saving or destroying a page outside
+#	of the scope of the controller (ie. from console)
+#	will also go unnoticed.
+#
+#	Interestingly, in unit/model testing, this fails
+#	as request is nil.  This means that I don't quite
+#	understand how this works.  Perhaps because the cache
+#	is in memory and not a file, the server and console
+#	are completely separate.  Destroying in the console
+#	doesn't effect the server's cache.  That makes sense.
+#	So then.  How to get the host_with_port without a 
+#	request then?
+class PageSweeper < ActionController::Caching::Sweeper
+	observe Page
+
+	#	After saving (creating or updating) a page,
+	#	expire any associated caches.
+	def after_save(page)
+		expire_cache(page)
+	end
+
+	#	After destroying a page, expire any associated
+	#	caches.
+	def after_destroy(page)
+		expire_cache(page)
+	end
+
+	#	Always expire the menu cache.  This may not
+	#	be necessary as it only relies on the menu,
+	#	path and position attributes which may have
+	#	remained unchanged.  Also expire the "show"
+	#	action cache.  As the pages are rarely accessed
+	#	via /pages/:id, we need to expire the special
+	#	routes used by the catch-all route.  In the 
+	#	real world, this works just fine, but in testing
+	#	the app tries to expire cache when in unit tests
+	#	as well as functional tests.  There is no 
+	#	"request" in a unit test causing failure and
+	#	my usage of ".try"
+	def expire_cache(page)
+		#	Please note that the "views/" prefix is
+		#	internal to rails.  Don't meddle with it.
+
+		#	Expired fragment: views/page_menu (0.0ms)
+		expire_fragment 'page_menu'
+
+		#	We don't really access the pages via :id
+		#		but they can be so we need to deal with the cache.
+		#	Expired fragment: views/dev.sph.berkeley.edu:3000/pages/1 (0.0ms)
+		#	Expired fragment: views/dev.sph.berkeley.edu:3000/pages/5 (0.0ms)
+		expire_action
+
+		#	Expired fragment: views/dev.sph.berkeley.edu:3000/alpha (0.0ms)
+		#	Expired fragment: views/dev.sph.berkeley.edu:3000/ (0.0ms)
+		#	This fails for the home page as "/" is 
+		#		called "index" by the server
+		#	NEEDS to change page.path to /index for home page
+		#		be views/dev.sph.berkeley.edu:3000/index !
+		page_path = ( page.path == "/" ) ? "/index" : page.path
+#		expire_fragment "#{request.host_with_port}#{page_path}"
+		expire_fragment "#{request.try(:host_with_port)}#{page_path}"
+
+		#	In production, the page caches weren't expiring
+		#	Adding the relative_url_root should fix it.
+		page_path = ActionController::Base.relative_url_root.to_s + page_path
+		expire_fragment "#{request.try(:host_with_port)}#{page_path}"
+
+	end
+
+end

data/generators/simply_pages/templates/simply_pages.rake

@@ -0,0 +1,5 @@
+#	From `script/generate simply_pages` ...
+unless Gem.source_index.find_name('jakewendt-simply_pages').empty?
+	gem 'jakewendt-simply_pages'
+	require 'simply_pages/test_tasks'
+end

data/generators/simply_pages/templates/stylesheets/page.css

@@ -0,0 +1,17 @@
+input[type='text'],
+textarea {
+	width: 99%;
+}
+
+div.parent {
+	float:left;
+}
+div.locale {
+	float:left;
+}
+div.hide_menu {
+	float:right;
+}
+div.fields {
+	clear:left;
+}

data/generators/simply_pages/templates/stylesheets/pages.css

@@ -0,0 +1,22 @@
+.page img.handle {
+}
+.page .position {
+	font-weight:bold;
+	text-align:center;
+}
+.page .path {
+	width: 140px;
+}
+.page .menu {
+	width: 140px;
+}
+.page .title {
+	width: 140px;
+}
+.page .manage {
+	text-align:right;
+}
+
+.page.row.ui-sortable-helper {
+	border: 1px dashed #E7C254;
+}

data/generators/simply_pages/templates/unit/page_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+class PageTest < ActiveSupport::TestCase
+
+	assert_should_require(:path,:menu_en,:title_en,:body_en)
+	assert_should_require_unique(:path,:menu_en)
+	assert_should_require_attribute_length(:path,:minimum => 1)
+	assert_should_require_attribute_length(:menu_en,:title_en,:body_en,
+		:minimum => 4)
+
+	test "should create page" do
+		assert_difference 'Page.count' do
+			page = create_page
+			assert !page.new_record?, 
+				"#{page.errors.full_messages.to_sentence}"
+		end
+	end
+
+	test "should require path begin with slash" do
+		assert_no_difference 'Page.count' do
+			page = create_page(:path => 'Hey')
+			assert page.errors.on(:path)
+		end
+	end
+
+	test "should filter out multiple continguous slashes" do
+		page = create_page(:path => "///a//b///c" )
+		assert_equal "/a/b/c", page.path
+	end
+
+	test "should downcase path" do
+		page = create_page(:path => "/A/B/C")
+		assert_equal "/a/b/c", page.path
+	end
+
+	test "can have a parent" do
+		parent = create_page
+		page = create_page( :parent_id => parent.id )
+		assert_equal page.reload.parent, parent
+	end
+
+	test "should return self as root with no parent" do
+		page = create_page
+		assert_equal page, page.root
+	end
+
+	test "should return parent as root with parent" do
+		parent = create_page
+		page = create_page( :parent_id => parent.id )
+		assert_equal parent, page.reload.root
+	end
+
+	test "should nullify parent_id of children when parent destroyed" do
+		parent = create_page
+		child  = create_page( :parent_id => parent.id )
+		assert_equal child.reload.parent_id, parent.id
+		parent.destroy
+		assert_nil child.reload.parent_id
+	end
+
+	test "should return false if page is not home" do
+		page = create_page
+		assert !page.is_home?
+	end
+
+	test "should return true if page is home" do
+		page = create_page(:path => '/')
+		assert page.is_home?
+	end
+
+	test "should create page with hide_menu true" do
+		assert_difference('Page.count',1){
+		assert_difference('Page.roots.count',0){
+			page = create_page(:hide_menu => true)
+#			assert_equal 1, Page.count
+#			assert_equal 0, Page.roots.count
+			assert_not_nil Page.find(page)
+			assert_not_nil Page.find(page.id)
+			assert_not_nil Page.find_by_path(page.path)
+		} }
+	end
+
+	test "should find page by path" do
+		p = create_page
+		page = Page.by_path(p.path)
+		assert_equal p, page
+	end
+
+	test "should return english menu without locale" do
+		p = create_page
+		assert_equal p.menu, p.menu_en
+	end
+
+	test "should return english title without locale" do
+		p = create_page
+		assert_equal p.title, p.title_en
+	end
+
+	test "should return english body without locale" do
+		p = create_page
+		assert_equal p.body, p.body_en
+	end
+
+	test "should return english menu with locale" do
+		p = create_page
+		assert_equal p.menu('en'), p.menu_en
+	end
+
+	test "should return english title with locale" do
+		p = create_page
+		assert_equal p.title('en'), p.title_en
+	end
+
+	test "should return english body with locale" do
+		p = create_page
+		assert_equal p.body('en'), p.body_en
+	end
+
+	test "should return spanish menu with locale" do
+		p = create_page(:menu_es => 'spanish menu')
+		assert_equal p.menu('es'), p.menu_es
+	end
+
+	test "should return spanish title with locale" do
+		p = create_page(:title_es => 'spanish title')
+		assert_equal p.title('es'), p.title_es
+	end
+
+	test "should return spanish body with locale" do
+		p = create_page(:body_es => 'spanish body')
+		assert_equal p.body('es'), p.body_es
+	end
+
+	test "should return english menu with missing spanish locale" do
+		p = create_page(:menu_es => '')
+		assert_equal p.menu('es'), p.menu_en
+	end
+
+	test "should return english title with missing spanish locale" do
+		p = create_page(:title_es => '')
+		assert_equal p.title('es'), p.title_en
+	end
+
+	test "should return english body with missing spanish locale" do
+		p = create_page(:body_es => '')
+		assert_equal p.body('es'), p.body_en
+	end
+
+end