strelka-cms 0.2.0 → 0.3.0

data/{data/strelka-cms/apps/content-manager → lib/strelka/cms/publisher.rb}

@@ -11,7 +11,7 @@ require 'strelka/mixins'
 require 'strelka/cms'
 
 
-class Strelka::CMS::ContentManager < Strelka::App
+class Strelka::CMS::Publisher < Strelka::App
 	extend Loggability,
 	       Configurability,
 	       Strelka::MethodUtilities
@@ -81,11 +81,17 @@ class Strelka::CMS::ContentManager < Strelka::App
 	end
 
 
+	##
+	# The Strelka::CMS::PageCatalog for the page root.
+	attr_reader :catalog
+
+
 	#
 	# Handler Routes
 	#
 	plugin :routing
 
+
 	# /
 	# -> /.page
 	# -> /index.page
@@ -100,47 +106,66 @@ class Strelka::CMS::ContentManager < Strelka::App
 	# -> /foo/project.html (literal)
 	# -> /foo/project/index.html (literal)
 
+	### GET /.*
 	get do |request|
+		path = self.get_page_path( request )
+
+		# If there was a matching .page file, use that
+		if page = self.get_page_for( path )
+			self.log.debug "  found page: %p" % [ page ]
+			return self.make_page_response( page )
+
+		# Try a literal HTML page
+		elsif htmlpage = self.get_html_path( path )
+			return self.make_raw_response( request, htmlpage )
+
+		else
+			# Give up
+			self.log.error "No pages matching %p" % [ path ]
+			finish_with HTTP::NOT_FOUND
+		end
+	end
+
+
+	### Return the page requested by the specified +request+ as a Pathname relative to the
+	### application path.
+	def get_page_path( request )
 		unless path = request.app_path[ PAGE_PATH_PATTERN, :path ]
 			self.log.error "Invalid app_path: %p" % [ request.app_path ]
 			finish_with HTTP::NOT_FOUND
 		end
 
 		# Force the path to be relative and clean it up
-		path = Pathname( path.gsub(%r{\A\.?/+|/(?=/)|/+\z}, '') )
-		page = nil
+		return Pathname( path.gsub(%r{\A\.?/+|/(?=/)|/+\z}, '') )
+	end
+
+
+	### Look for a static .html file in the catalog and return a Pathname for it if
+	### one exists.
+	def get_html_path( path )
+		path = self.class.pageroot + path.sub_ext( '.html' )
+		return path if path.exist?
+		return nil
+	end
+
 
-		# Try to find a matching .page file
+	### Find a page that corresponds to the specified +path+ (a Pathname). Returns +nil+ if
+	### no matching page was found.
+	def get_page_for( path )
 		self.log.debug "Page path is: %p" % [ path ]
 		if path.to_s.empty?
 			subcat = @catalog.matching_pattern( 'index.page' )
-			page = subcat.first
+			return subcat.first
 		else
 			subcat = @catalog.relative_to( path.dirname ).
 				matching_pattern( "#{path.basename(path.extname)}{.page,/index.page}" )
-			page = subcat.first
+			return subcat.first
 		end
-
-		# If there was a matching .page file, use that
-		if page
-			self.log.debug "  found page: %p" % [ page ]
-			return self.page_response( page )
-		end
-
-		# Try a literal HTML page
-		htmlpage = self.class.pageroot + path.sub_ext( '.html' )
-		if htmlpage.exist?
-			return self.raw_response( request, htmlpage )
-		end
-
-		# Give up
-		self.log.error "No pages matching %p" % [ path ]
-		finish_with HTTP::NOT_FOUND
 	end
 
 
 	### Package up the specified +page+ in the page template and return it.
-	def page_response( page )
+	def make_page_response( page )
 		tmpl = self.template( :page )
 		tmpl.page = page
 		return tmpl
@@ -148,14 +173,11 @@ class Strelka::CMS::ContentManager < Strelka::App
 
 
 	### Package up the page at the specified +path+ in the response and return it.
-	def raw_response( request, pagepath )
+	def make_raw_response( request, pagepath )
 		response = request.response
 		response.body = pagepath.open( 'r', encoding: 'utf-8' )
 		return response
 	end
 
-end # class Strelka::CMS::ContentManager
-
-Encoding.default_internal = Encoding::UTF_8
-Strelka::CMS::ContentManager.run if __FILE__ == $0
+end # class Strelka::CMS::Publisher
 

data/spec/{lib/helpers.rb → helpers.rb}

@@ -1,20 +1,6 @@
 #!/usr/bin/ruby
 # coding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
-
-	srcdir = basedir.parent
-	strelkadir = srcdir + 'Strelka/lib'
-
-	libdir = basedir + "lib"
-
-	$LOAD_PATH.unshift( strelkadir.to_s ) unless $LOAD_PATH.include?( strelkadir.to_s )
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
-
 # SimpleCov test coverage reporting; enable this using the :coverage rake task
 if ENV['COVERAGE']
 	$stderr.puts "\n\n>>> Enabling coverage report.\n\n"
@@ -38,6 +24,8 @@ require 'mongrel2/testing'
 require 'strelka'
 require 'strelka/cms'
 
+require 'fakefs/spec_helpers'
+
 
 ### RSpec helper functions.
 module Strelka::CMS::SpecHelpers
@@ -47,7 +35,9 @@ end
 
 ### Mock with RSpec
 RSpec.configure do |c|
-	c.mock_with( :rspec )
+	c.mock_with( :rspec ) do |config|
+		config.syntax = :expect
+	end
 
 	c.include( Loggability::SpecHelpers )
 	c.include( Mongrel2::SpecHelpers )

data/spec/strelka/cms/page_spec.rb

@@ -2,21 +2,13 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../../helpers'
 
 require 'pathname'
 require 'tmpdir'
 require 'tempfile'
 require 'stringio'
 
-require 'rspec'
-
-require 'spec/lib/helpers'
-require 'strelka/cms'
 require 'strelka/cms/page'
 
 
@@ -88,10 +80,10 @@ describe Strelka::CMS::Page do
 
 		page = described_class.load( tmp.path )
 
-		page.title.should == 'Fun With TextMate 2'
-		page.tags.should include( 'editors', 'software', 'tools', 'textmate2' )
-		page.content.should include( 'One of the things that kept me from switching' )
-		page.path.to_s.should == tmp.path
+		expect( page.title ).to eq( 'Fun With TextMate 2' )
+		expect( page.tags ).to include( 'editors', 'software', 'tools', 'textmate2' )
+		expect( page.content ).to include( 'One of the things that kept me from switching' )
+		expect( page.path.to_s ).to eq( tmp.path )
 	end
 
 	it "can read a page from an IO stream" do
@@ -99,17 +91,17 @@ describe Strelka::CMS::Page do
 
 		page = described_class.read( io )
 
-		page.title.should == 'Fun With TextMate 2'
-		page.tags.should include( 'editors', 'software', 'tools', 'textmate2' )
-		page.content.should include( 'One of the things that kept me from switching' )
+		expect( page.title ).to eq( 'Fun With TextMate 2' )
+		expect( page.tags ).to include( 'editors', 'software', 'tools', 'textmate2' )
+		expect( page.content ).to include( 'One of the things that kept me from switching' )
 	end
 
 	it "can parse a page from source" do
 		page = described_class.parse( TEST_DOCUMENT )
 
-		page.title.should == 'Fun With TextMate 2'
-		page.tags.should include( 'editors', 'software', 'tools', 'textmate2' )
-		page.content.should include( 'One of the things that kept me from switching' )
+		expect( page.title ).to eq( 'Fun With TextMate 2' )
+		expect( page.tags ).to include( 'editors', 'software', 'tools', 'textmate2' )
+		expect( page.content ).to include( 'One of the things that kept me from switching' )
 	end
 
 
@@ -118,16 +110,16 @@ describe Strelka::CMS::Page do
 		let( :page ) { described_class.parse(TEST_DOCUMENT) }
 
 		it "can generate a summary of its contents" do
-			page.summary.should =~ /^If you're using the WebKit formatter,/
+			expect( page.summary ).to match( /^If you're using the WebKit formatter,/ )
 		end
 
 		it "can generate a list of topics from its content" do
-			page.summary_topics.should include( "formatter", "rspec" )
+			expect( page.summary_topics ).to include( "formatter", "rspec" )
 		end
 
 		it "can generate keywords if none are set by the header" do
 			page.instance_variable_set( :@tags, nil )
-			page.keywords.should include( 'formatter', 'rspec', 'editor', 'textmate' )
+			expect( page.keywords ).to include( 'formatter', 'rspec', 'editor', 'textmate' )
 		end
 
 	end
@@ -140,15 +132,15 @@ describe Strelka::CMS::Page do
 
 
 		it "has a default set of filters" do
-			page.filters.should == %w[strip textile]
+			expect( page.filters ).to eq( %w[strip textile] )
 		end
 
 		it "returns its contents after applying filters when stringified" do
-			page.to_s.should == %{<h1>Title</h1>\n<p>Some content.</p>}
+			expect( page.to_s ).to eq( %{<h1>Title</h1>\n<p>Some content.</p>} )
 		end
 
 		it "can return its first heading" do
-			page.first_heading.should == 'Title'
+			expect( page.first_heading ).to eq( 'Title' )
 		end
 
 	end
@@ -177,7 +169,7 @@ describe Strelka::CMS::Page do
 
 
 		it "knows what its path relative to its catalog's base is" do
-			page.relative_path.should == relative_pagefile_pathname
+			expect( page.relative_path ).to eq( relative_pagefile_pathname )
 		end
 
 	end

data/spec/strelka/cms/pagecatalog_spec.rb

@@ -2,22 +2,8 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
-
-require 'pathname'
-require 'tmpdir'
-require 'tempfile'
-require 'stringio'
-
-require 'rspec'
-
-require 'spec/lib/helpers'
-require 'strelka/cms'
-require 'strelka/cms/page'
+require_relative '../../helpers'
+
 require 'strelka/cms/pagecatalog'
 
 
@@ -26,10 +12,16 @@ require 'strelka/cms/pagecatalog'
 #####################################################################
 
 describe Strelka::CMS::PageCatalog do
+	include FakeFS::SpecHelpers
 
 	before( :all ) do
 		setup_logging()
-		@basedir = Pathname( __FILE__ ).dirname.parent.parent.parent
+	end
+
+	before( :each ) do
+		FileUtils.mkdir_p( '/var/www/local/test' )
+		FileUtils.mkdir_p( '/var/www/local/lib' )
+		Dir.chdir( '/var/www/local' )
 	end
 
 	after( :all ) do
@@ -42,7 +34,27 @@ describe Strelka::CMS::PageCatalog do
 		subject { described_class.new }
 
 		it "has a glob pattern that matches .page files under the current directory" do
-			subject.glob.should == "#{Dir.pwd}/**/*.page"
+			expect( subject.glob ).to eq( "/var/www/local/**/*.page" )
+		end
+
+		it "can load page files by name" do
+			FileUtils.touch( '/var/www/local/test/index.page' )
+
+			page = subject['test/index']
+
+			expect( page ).to be_a( Strelka::CMS::Page )
+			expect( page.path.to_s ).to eq( '/var/www/local/test/index.page' )
+			expect( page.catalog ).to be( subject )
+		end
+
+		it "doesn't require the .page extension when loading page files by name" do
+			FileUtils.touch( '/var/www/local/test/index.page' )
+
+			page = subject['test/index']
+
+			expect( page ).to be_a( Strelka::CMS::Page )
+			expect( page.path.to_s ).to eq( '/var/www/local/test/index.page' )
+			expect( page.catalog ).to be( subject )
 		end
 
 	end
@@ -50,11 +62,11 @@ describe Strelka::CMS::PageCatalog do
 
 	context "created with a base directory" do
 
-		subject { described_class.new(@basedir) }
+		subject { described_class.new('/var/www') }
 
 
 		it "has a glob pattern that matches .page files under the directory it was created with" do
-			subject.glob.should == "#@basedir/**/*.page"
+			expect( subject.glob ).to eq( "/var/www/**/*.page" )
 		end
 
 	end
@@ -62,28 +74,32 @@ describe Strelka::CMS::PageCatalog do
 
 	context "created with a base directory and a glob pattern" do
 
-		subject { described_class.new(@basedir, '**/*.rb') }
+		subject { described_class.new('/var/www/local', '**/*.rb') }
 
 
 		it "has a glob pattern that matches files that match the pattern under the directory it was " +
 		   "created with" do
-			subject.glob.should == "#@basedir/**/*.rb"
+			expect( subject.glob ).to eq( "/var/www/local/**/*.rb" )
 		end
 
 		it "has a mutator that clones it for a subdirectory" do
-			subject.relative_to( 'lib' ).glob.should == "#@basedir/lib/**/*.rb"
+			expect( subject.relative_to('lib').glob ).to eq( "/var/www/local/lib/**/*.rb" )
 		end
 
 		it "has a mutator that clones it for a different glob pattern" do
-			subject.matching_pattern( "*.txt" ).glob.should == "#@basedir/*.txt"
+			expect( subject.matching_pattern('*.txt').glob ).to eq( "/var/www/local/*.txt" )
 		end
 
 		it "has an iterator that yields files that match its glob pattern" do
-			subject.relative_to( 'lib' ).map( &:path ).should include( @basedir + 'lib/strelka/cms.rb' )
+			pending "Database rewrite"
+			FileUtils.touch( '/var/www/local/lib/payment.rb' )
+
+			expect( subject.relative_to('lib').map(&:path) ).
+				to include( Pathname('/var/www/local/lib/payment.rb') )
 		end
 
 		it "strips leading directory separators from relative paths" do
-			subject.relative_to( '/lib' ).glob.should == "#@basedir/lib/**/*.rb"
+			expect( subject.relative_to( '/lib' ).glob ).to eq( "/var/www/local/lib/**/*.rb" )
 		end
 
 

data/spec/strelka/cms/pagefilter/autoindex_spec.rb

@@ -0,0 +1,83 @@
+# -*- ruby -*-
+# encoding: utf-8
+# vim: set nosta noet ts=4 sw=4:
+
+require_relative '../../../helpers'
+
+require 'tmpdir'
+require 'strelka/cms'
+require 'strelka/cms/pagefilter'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::CMS::PageFilter, 'AutoIndex' do
+
+	SIMPLE_TEST_SOURCE = (<<-END_PAGE_SOURCE).gsub( /^\t{2}/, '' ).freeze
+		<?autoindex /blog/*.page ?>
+	END_PAGE_SOURCE
+
+	before( :all ) do
+		# Need to load this before fakefs hides the filesystem
+		Inversion::Template::Tag.load_all
+	end
+
+
+	around( :each ) do |example|
+		Dir.mktmpdir( "autoindex_spec" ) do |dirname|
+			@tmpdir = dirname
+			example.call
+		end
+	end
+
+
+
+	it "is ignored when used from a page that isn't part of a catalog" do
+		filter = described_class.create( 'autoindex' )
+
+		page = Strelka::CMS::Page.parse( SIMPLE_TEST_SOURCE )
+		output = filter.process( SIMPLE_TEST_SOURCE, page )
+
+		expect( output ).to match( /<!-- autoindex skipped/i )
+	end
+
+
+	it "renders an index of the matched files in the page's catalog" do
+		pending "Database rewrite"
+		FileUtils.mkdir_p( "#@tmpdir/content/blog" )
+		FileUtils.mkdir_p( "#@tmpdir/templates/autoindex" )
+
+		FileUtils.touch( "#@tmpdir/content/blog/post1.page" )
+		FileUtils.touch( "#@tmpdir/content/blog/post2.page" )
+		FileUtils.touch( "#@tmpdir/content/blog/post3.page" )
+
+		File.open( "#@tmpdir/content/test.page", 'w' ) do |fh|
+			fh.print( SIMPLE_TEST_SOURCE )
+		end
+
+		File.open( "#@tmpdir/templates/autoindex/default.tmpl", 'w' ) do |fh|
+			fh.puts "<?for page in pages ?>"
+			fh.puts "-<?call page.relative_html_path ?>-"
+			fh.puts "<?end for ?>"
+		end
+
+		Inversion::Template.template_paths.replace( ["#@tmpdir/templates"] )
+
+		catalog = Strelka::CMS::PageCatalog.new( "#@tmpdir/content", '**/*.page' )
+		page = catalog.find {|page| page.relative_path.to_s == 'test.page' } or
+			raise "didn't find test.page in catalog %p" % [ catalog ]
+
+		filter = described_class.create( 'autoindex' )
+		output = filter.process( SIMPLE_TEST_SOURCE, page )
+
+		expect( output ).to match( /post1\.html/ )
+		expect( output ).to match( /post2\.html/ )
+		expect( output ).to match( /post3\.html/ )
+	end
+
+
+
+end
+