jarrett-quarto 1.1.0 → 1.2.0

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0

data/lib/quarto/element_wrapper.rb

@@ -89,6 +89,7 @@ module Quarto
 			#
 			# * <tt>:xpath</tt> - An XPath expression to limit the search. If this option is not given, the default XPath is "//element_name"
 			def self.find(quantifier, options = {})
+				raise 'You must call use_xml() in generate.rb before using the models' if xml_doc.nil?
 				raise ArgumentError, "Quantifier must be :all, :first, or :last, but got #{quantifier.inspect}" unless [:all, :first, :last].include?(quantifier)
 				raise ArgumentError, "Options must be a Hash, but got #{options.inspect}" unless options.is_a?(Hash)
 				if options.has_key?(:xpath)

data/lib/quarto/generator.rb

@@ -73,6 +73,10 @@ module Quarto
 			@console = @options[:console]
 		end
 		
+		def urls_file_path # :nodoc:
+			@project_path + '/urls.rb'
+		end
+		
 		attr_reader :output_path # :nodoc:
 		
 		protected
@@ -111,7 +115,7 @@ module Quarto
 			else
 				subdir = "#{@output_path}/#{directory}"
 				if !File.exists? subdir
-					Dir.mkdir subdir
+					FileUtils::mkdir_p subdir
 				end
 				path = "#{subdir}/#{filename}"
 			end
@@ -124,9 +128,11 @@ module Quarto
 		# Renders +template+ to a string. Sets local variables within the template to the values given
 		# in +locals+.
 		def render_to_s(template, locals, options = {})
+			require urls_file_path
+			
 			page_template_path = "#{@project_path}/pages/#{template}"
 			page_template = ERB.new(File.read(page_template_path))
-			page_content = Rendering.render(page_template, locals)
+			page_content = Rendering.render(page_template, locals, [Quarto::ProjectUrls])
 			
 			if options.has_key?(:layout)
 				layout = options[:layout]
@@ -141,8 +147,9 @@ module Quarto
 			
 			if layout
 				layout_template_path = "#{@project_path}/layouts/#{layout}"
+				raise ArgumentError, "Template doesn't exist: #{layout_template_path}" unless File.exists?(layout_template_path)
 				layout_template = ERB.new(File.read(layout_template_path))
-				Rendering.render(layout_template, locals) do
+				Rendering.render(layout_template, locals, [Quarto::ProjectUrls]) do
 					page_content
 				end
 			else

data/lib/quarto/init_project.rb

@@ -13,6 +13,16 @@ Quarto.generate do
 	# e.g.:
 	# render 'companies.html.erb', '', 'companies.html', :companies => Company.find(:all)
 end
+)
+
+	STARTER_URLS_FILE = %q(
+module Quarto
+	module ProjectUrls
+		include Quarto::UrlHelper
+		
+		
+	end
+end
 )
 	# Initialize a new Quarto project at the specified path. Creates a generate.rb file and the necessary subfolders.
 	def self.init_project(project_path)
@@ -33,6 +43,12 @@ end
 				file.print(STARTER_GENERATE_FILE)
 			end
 		end
+		urls_file = project_path + '/urls.rb'
+		unless File.exists?(urls_file)
+			File.open(urls_file, 'w') do |file|
+				file.print(STARTER_URLS_FILE)
+			end
+		end
 		true
 	end
 end

data/lib/quarto/rendering.rb

@@ -1,11 +1,31 @@
 module Quarto
 	class Rendering # :nodoc: all
-		include UrlHelper
+		include Quarto::UrlHelper
 		
-		def initialize(__erb_template, __locals)
+		def initialize(__erb_template, __locals, __mixins)
+			unless __erb_template.is_a?(ERB)
+				raise ArgumentError, "Expected ERB but got #{__erb_template.inspect}"
+			end
+			
+			unless __locals.is_a?(Hash)
+				raise ArgumentError, "Expected Hash but got #{__locals.inspect}"
+			end
+			
+			unless __mixins.is_a?(Array)
+				raise ArgumentError, "Expected Array but got #{__mixins.inspect}"
+			end
+			
+			__mixins.each do |mixin|
+				unless mixin.is_a?(Module)
+					raise ArgumentError, "Expected Module but got #{mixin.inspect}"
+				end
+				extend(mixin)
+			end
+			
 			__b = binding
+			
 			__locals.each_key do |var_name|
-				# In the context of this method (rather than of this block),
+				# In the context of the binding (rather than of this block),
 				# define the local variables
 				eval "#{var_name} = __locals[:#{var_name}]", __b
 			end
@@ -13,8 +33,8 @@ module Quarto
 			@result = __erb_template.result(__b)
 		end
 		
-		def self.render(erb_template, locals, &block)
-			new(erb_template, locals, &block).result
+		def self.render(erb_template, locals, mixins = [], &block)
+			new(erb_template, locals, mixins, &block).result
 		end
 		
 		attr_reader :result

data/lib/quarto/url_helper.rb

@@ -1,10 +1,20 @@
 require 'cgi'
+require 'uri'
 
 module Quarto
 	
 	# This module is included in Generator and thus made available in <tt>generate.rb</tt> files.
 	
 	module UrlHelper
+		def self.included(base)
+			if defined? RAILS_GEM_VERSION
+				base.class_eval do
+					alias_method :url_for_without_element_wrapper, :url_for
+					alias_method :url_for, :url_for_with_element_wrapper
+				end
+			end
+		end
+		
 		# Generates an absolute URL, using the <tt>:site_root</tt> config value. (To change <tt>:site_root</tt>,
 		# put something like this in <tt>generate.rb</tt>:
 		#   config(:site_root, 'http://your_domain.com/whatever')
@@ -12,9 +22,64 @@ module Quarto
 			"#{Quarto.config[:site_root]}#{str}"
 		end
 		
+		def url_for_with_element_wrapper(options = {})
+			if options.is_a?(Quarto::ElementWrapper::Base)
+				if options.respond_to?(:to_path)
+					return options.to_path
+				else
+					raise "#{options.class} must define to_path if you want to pass an instance into link_to or url_for"
+				end
+			else
+				if defined? RAILS_GEM_VERSION
+					return url_for_without_element_wrapper(options)
+				else
+					raise ArgumentError, "Don\'t know how to generate URL from #{options.inspect}"
+				end
+			end
+		end
+		
 		# Replaces spaces with dashes and deletes special characters.
 		def urlize(str)
 			str.to_s.gsub(/[^ a-zA-Z0-9_-]/, '').tr(' ', '-')
 		end
+			
+		unless defined? RAILS_GEM_VERSION
+			# Similar to Rails' <tt>link_to</tt>, but with less flexibility. Anything you pass to this
+			# <tt>link_to</tt> will also work in Rails, but the reverse is not true.
+			#
+			# This method is only defined if you're not using Quarto within Rails. If you are,
+			# the Rails <tt>link_to</tt> will not be overriden by this one. However, you can still pass
+			# instances of <tt>ElementWrapper::Base</tt> in, because Quarto patches <tt>url_for</tt> (which is
+			# called by Rails' <tt>link_to</tt>).
+			#
+			# +target+ must be either an instance of <tt>ElementWrapper::Base</tt>, an absolute URL, or
+			# a relative URL.
+			def link_to(text, target, options = {})
+				if !target.is_a?(String) and !target.is_a?(Quarto::ElementWrapper::Base)
+					raise ArgumentError, "Expected String or ElementWrapper::Base, but got #{target.inspect}"
+				end
+				url = url_for(target)
+				options = {:html_options => {}}.merge(options)
+				output = "<a href=\"#{url}\""
+				options[:html_options].each do |attr, value|
+					output << " #{attr}=\"#{value}\""
+				end
+				output + '>' + text + '</a>'
+			end
+			
+			# Somewhat compatible with the Rails url_for helper.
+			def url_for(options = {})
+				if options.is_a?(String)
+					uri = URI.parse(options)
+					if uri.absolute?
+						uri.to_s
+					else
+						abs_url(uri.to_s)
+					end
+				else
+					url_for_with_element_wrapper(options)
+				end
+			end
+		end
 	end
 end

data/lib/quarto.rb

@@ -4,6 +4,7 @@ require 'rubygems'
 require 'rexml/document'
 require 'erb'
 require 'active_support/inflector'
+require 'fileutils'
 
 require 'quarto/config'
 require 'quarto/xml_doc'

data/quarto.gemspec

@@ -0,0 +1,72 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{quarto}
+  s.version = "1.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jarrett Colby"]
+  s.date = %q{2009-06-09}
+  s.default_executable = %q{quarto}
+  s.description = %q{Quarto is a Ruby framework for generating collections of documents from XML. It steps in where XSLT just won't cut it. Potential applications include web sites and e-books. It's built on top of ERB and REXML.}
+  s.email = %q{jarrett@uchicago.edu}
+  s.executables = ["quarto"]
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "Rakefile",
+     "VERSION",
+     "bin/quarto",
+     "lib/quarto.rb",
+     "lib/quarto/children.rb",
+     "lib/quarto/config.rb",
+     "lib/quarto/element_wrapper.rb",
+     "lib/quarto/generator.rb",
+     "lib/quarto/inheritable_attributes.rb",
+     "lib/quarto/init_project.rb",
+     "lib/quarto/rendering.rb",
+     "lib/quarto/url_helper.rb",
+     "lib/quarto/xml_doc.rb",
+     "quarto.gemspec",
+     "test.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/jarrett/quarto}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{generates HTML or any other format from XML}
+  s.test_files = [
+    "spec/children_spec.rb",
+     "spec/element_wrapper_spec.rb",
+     "spec/generator_spec.rb",
+     "spec/init_project_spec.rb",
+     "spec/matchers/file_matchers.rb",
+     "spec/rendering_spec.rb",
+     "spec/sample_models.rb",
+     "spec/sample_project/generate.rb",
+     "spec/sample_project/models/company.rb",
+     "spec/sample_project/models/employee.rb",
+     "spec/sample_project/models/location.rb",
+     "spec/sample_project/models/mascot.rb",
+     "spec/sample_project/models/product.rb",
+     "spec/sample_project/urls.rb",
+     "spec/spec_helper.rb",
+     "spec/url_helper_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.2"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+  end
+end

data/spec/generator_spec.rb

@@ -38,23 +38,6 @@ describe Quarto do
 	end
 end
 
-module Quarto
-	# This will be used in the specs below--see the method aliasing
-	def self.testable_generate(&block)
-		GenerationTesting.generation_block = block
-	end
-	
-	module GenerationTesting
-		def self.generation_block
-			@generation_block
-		end
-		
-		def self.generation_block=(block)
-			@generation_block = block
-		end
-	end
-end
-
 describe Quarto::Generator do
 	context '.new' do
 		it 'should accept a path to a project directory' do
@@ -66,32 +49,61 @@ describe Quarto::Generator do
 		include Quarto::UrlHelper
 		
 		before :all do
-			# Quarto.generate will now return the passed block as a proc
-			# instead of envoking the whole framework
-			Quarto.module_eval do
+			module Quarto
+				def self.testable_generate(&block)
+					GenerationTesting.generation_block = block
+				end
+				
+				# Quarto.generate will now return the passed block as a proc
+				# instead of envoking the whole framework.
+				# This would prevent the generation directives from being
+				# processed at all, except that below, we call
+				# @generator.generate with the saved block
 				class << self
-					
 					alias_method :untestable_generate, :generate
 					alias_method :generate, :testable_generate
 				end
+				
+				module GenerationTesting
+					def self.generation_block
+						@generation_block
+					end
+					
+					def self.generation_block=(block)
+						@generation_block = block
+					end
+					
+					def self.last_rendering
+						@last_rendering
+					end
+					
+					def self.last_rendering=(rendering)
+						@last_rendering = rendering
+					end
+				end
 			end
 			
 			@generator = Quarto::Generator.new(SAMPLE_DIR)
 			
-			# Clear the directories
+			# Clear the directories prior to testing
 			FileUtils.rm_rf @generator.output_path
 			
-			# Now that we've aliased the methods and load has been called GenerationTesting.generation_block should be set
+			# Now that we've aliased the methods and load has been called
+			# GenerationTesting.generation_block should be set, so
+			# we can execute the generation block.
 			load @generator.generate_file_path
 			@generator.generate(&Quarto::GenerationTesting.generation_block)
 		end
 		
 		after :all do
 			# Reset Quarto.generate to its old behavior
-			Quarto.module_eval do
+			module Quarto
 				class << self
 					alias_method :generate, :untestable_generate
+					remove_method :testable_generate
 				end
+				
+				remove_const :GenerationTesting
 			end
 		end
 		

data/spec/rendering_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Quarto::Rendering do
+	context '.render' do
+		it 'should use the ERB template' do
+			template = ERB.new 'foo bar'
+			Quarto::Rendering.render(template, {}).should == 'foo bar'
+		end
+		
+		it 'should set the local variables' do
+			template = ERB.new 'The value of x is <%= x %>.'
+			Quarto::Rendering.render(template, {:x => 42}).should == 'The value of x is 42.'
+		end
+		
+		it 'should mix in the modules' do
+			module SomeMixin
+				def foo; 42; end
+			end
+			template = ERB.new 'SomeMixin#foo returns <%= foo %>.'
+			Quarto::Rendering.render(template, {}, [SomeMixin]).should == 'SomeMixin#foo returns 42.'
+			Object.class_eval do
+				remove_const :SomeMixin
+			end
+		end
+		
+		it 'should raise ArgumentError if the first parameter is not an ERB template' do
+			lambda { Quarto::Rendering.render('foo bar', {}) }.should raise_error(ArgumentError)
+		end
+		
+		it 'should raise ArgumentError if the second parameter is not a hash' do
+			template = ERB.new 'foo bar'
+			lambda { Quarto::Rendering.render(template, [:x, 42]) }.should raise_error(ArgumentError)
+		end
+		
+		it 'should raise ArgumentError if the third parameter is not an array of modules' do
+			module SomeMixin; end
+			template = ERB.new 'foo bar'
+			lambda { Quarto::Rendering.render(template, {}, SomeMixin) }.should raise_error(ArgumentError)
+			lambda { Quarto::Rendering.render(template, {}, [SomeMixin, 'foo']) }.should raise_error(ArgumentError)
+			Object.class_eval do
+				remove_const :SomeMixin
+			end
+		end
+	end
+end

data/spec/sample_project/generate.rb

@@ -1,5 +1,5 @@
 Quarto.generate do
-	config(:site_root, 'http://localhost/') # This determines how abs_url works.
+	config(:site_root, '') # This determines how abs_url works. If you need your absolute URLs to be prepended with something, you can put it here.
 
 	use_xml('companies.xml')
 

data/spec/sample_project/models/company.rb

@@ -12,4 +12,8 @@ class Company < Quarto::ElementWrapper::Base
 	def competitors
 		@competitors ||= self.class.find(:all, :xpath => "companies/company[industry='#{industry}' and name!='#{name}']")
 	end
+	
+	def to_path
+		'companies.html'
+	end
 end

data/spec/sample_project/models/employee.rb

@@ -1,4 +1,6 @@
 class Employee < Quarto::ElementWrapper::Base
+	include Quarto::UrlHelper
+	
 	element_attrs :name
 	
 	parent :company
@@ -7,4 +9,8 @@ class Employee < Quarto::ElementWrapper::Base
 		employee = new(el)
 		employee.ivs_from_elements('name')
 	end
+	
+	def to_path
+		'employees/' + urlize(name) + '.html'
+	end
 end

data/spec/sample_project/urls.rb

@@ -0,0 +1,9 @@
+module Quarto
+	module ProjectUrls
+		include Quarto::UrlHelper
+		
+		def companies_url
+			abs_url('companies.html')
+		end
+	end
+end

data/spec/url_helper_spec.rb

@@ -12,12 +12,194 @@ describe Quarto::UrlHelper do
 			urlize('John Smith').should == 'John-Smith'
 		end
 		
-		it 'should not change numbers' do
-			urlize('a10b').should == 'a10b'
+		it 'should not change numbers without decimal points' do
+			['10', '-1', 'a10b'].each do |num|
+				urlize(num).should == num
+			end
+		end
+		
+		it 'should remove the . character' do
+			[
+				['foo.bar', 'foobar'],
+				['.foo', 'foo'],
+				['foo.', 'foo'],
+				['10.5', '105']
+			].each do |input, expected|
+				urlize(input).should == expected
+			end
 		end
 		
 		it 'should not change dashes and underscores' do
 			urlize('foo-bar_baz').should == 'foo-bar_baz'
 		end
 	end
+	
+	context '#link_to' do
+		context 'outside Rails' do
+			before :each do
+				if defined? RAILS_GEM_VERSION
+					raise 'RAILS_GEM_VERSION is defined. (It shouldn\'t be when running this spec)'
+				end
+				
+				class TemplateOutsideRails
+					include Quarto::UrlHelper
+				end
+			end
+			
+			after :each do
+				Object.class_eval do
+					remove_const :TemplateOutsideRails
+				end
+			end
+			
+			it 'should be defined' do
+				TemplateOutsideRails.new.should respond_to(:link_to)
+			end
+			
+			it 'should call url_for' do
+				template = TemplateOutsideRails.new
+				template.should_receive(:url_for)
+				template.link_to('foo', 'bar')
+			end
+			
+			it 'should return an HTML link' do
+				expected = '<a href="http://example.com/foo">foo</a>'
+				TemplateOutsideRails.new.link_to('foo', 'http://example.com/foo').should == expected
+			end
+			
+			it 'should use :html_options' do
+				expected = '<a href="http://example.com" onclick="javascript:alert(\'foo\');">Click me</a>'
+				template = TemplateOutsideRails.new
+				template.link_to(
+					'Click me', 'http://example.com',
+					:html_options => {:onclick => 'javascript:alert(\'foo\');'}
+				).should == expected
+			end
+		end
+		
+		context 'in Rails' do
+			it 'should not be redefined if RAILS_GEM_VERSION is defined' do
+				RAILS_GEM_VERSION = 'foo'
+				
+				class RailsTemplate
+					attr_reader :link_to_called
+					
+					def initialize
+						@link_to_called = false
+					end
+					
+					def link_to(*args)
+						@link_to_called = true
+					end
+					
+					include Quarto::UrlHelper
+				end
+				
+				template = RailsTemplate.new
+				template.link_to('bar')
+				template.link_to_called.should == true
+				
+				Object.class_eval do
+					remove_const :RailsTemplate
+					remove_const :RAILS_GEM_VERSION
+				end
+			end
+		end
+	end
+
+	context '#url_for' do
+		context 'outside Rails' do
+			before :each do
+				if defined? RAILS_GEM_VERSION
+					raise 'RAILS_GEM_VERSION is defined. (It shouldn\'t be when running this spec)'
+				end
+				
+				class TemplateOutsideRails
+					include Quarto::UrlHelper
+				end
+			end
+			
+			after :each do
+				Object.class_eval do
+					remove_const :TemplateOutsideRails
+				end
+			end
+			
+			it 'should be defined' do
+				TemplateOutsideRails.new.should respond_to(:url_for)
+			end
+			
+			it 'should raise ArgumentError if anything other than a string or an instance of ElementWrapper::Base is passed to it' do
+				class MockWrapper
+					def is_a?(klass); Quarto::ElementWrapper::Base == klass; end	
+					def to_path; 'foo'; end;
+				end
+				TemplateOutsideRails.new.url_for('foo')
+				TemplateOutsideRails.new.url_for(MockWrapper.new)
+				[1, 0.1, Date.new, URI.parse('http://foo.com')].each do |obj|
+					lambda { TemplateOutsideRails.new.url_for(obj) }.should raise_error(ArgumentError)
+				end
+				Object.class_eval do
+					remove_const :MockWrapper
+				end
+			end
+			
+			it 'should call abs_url if the parameter is a relative URL' do
+				['foo', '/foo'].each do |rel_url|
+					template = TemplateOutsideRails.new
+					template.should_receive(:abs_url).with(rel_url)
+					template.url_for(rel_url)
+				end
+			end
+			
+			it 'should not modify an absolute url' do
+				['http://example.com', 'http://example.com/foo', 'https://example.com', 'ftp://example.com'].each do |url|
+					TemplateOutsideRails.new.url_for(url).should == url
+				end
+			end
+		end
+
+		context 'in Rails' do
+			before :each do
+				RAILS_GEM_VERSION = 'foo'
+				
+				class RailsTemplate
+					attr_reader :url_for_called
+					
+					def initialize
+						@url_for_called = false
+					end
+					
+					def url_for(options = {})
+						@url_for_called = true
+					end
+					
+					include Quarto::UrlHelper
+				end
+			end
+			
+			after :each do
+				Object.class_eval do
+					remove_const :RAILS_GEM_VERSION
+					remove_const :RailsTemplate
+				end
+			end
+			
+			it 'should pass the parameter through to the Rails url_for if the parameter is not an ElementWrapper::Base' do
+				template = RailsTemplate.new
+				template.url_for('bar')
+				template.url_for_called.should == true
+			end
+		
+			it 'should call to_path if the parameter is an ElementWrapper::Base and RAILS_GEM_VERSION is defined' do
+				wrapper = mock
+				wrapper.stub!(:to_path).and_return('some_path')
+				wrapper.stub!(:is_a?).and_return(true)
+				wrapper.should_receive(:is_a?).with(Quarto::ElementWrapper::Base).and_return(true)
+				wrapper.should_receive(:to_path)
+				template = RailsTemplate.new
+				template.url_for(wrapper).should == 'some_path'
+			end
+		end
+	end
 end

data/test.rb

@@ -0,0 +1,20 @@
+require 'erb'
+
+module Foo
+	def foo
+		6
+	end
+end
+
+template = ERB.new %q(
+The value of x is <%= x %>
+The method foo returns <%= foo %>
+)
+x = 42
+
+b = binding
+
+eval 'include Foo', b
+
+template.extend(Foo)
+puts template.result(b)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jarrett-quarto
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Jarrett Colby
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-06 00:00:00 -07:00
+date: 2009-06-09 00:00:00 -07:00
 default_executable: quarto
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,7 +45,9 @@ files:
 - lib/quarto/rendering.rb
 - lib/quarto/url_helper.rb
 - lib/quarto/xml_doc.rb
-has_rdoc: false
+- quarto.gemspec
+- test.rb
+has_rdoc: true
 homepage: http://github.com/jarrett/quarto
 post_install_message: 
 rdoc_options: 
@@ -69,7 +71,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 3
+specification_version: 2
 summary: generates HTML or any other format from XML
 test_files: 
 - spec/children_spec.rb
@@ -77,6 +79,7 @@ test_files:
 - spec/generator_spec.rb
 - spec/init_project_spec.rb
 - spec/matchers/file_matchers.rb
+- spec/rendering_spec.rb
 - spec/sample_models.rb
 - spec/sample_project/generate.rb
 - spec/sample_project/models/company.rb
@@ -84,5 +87,6 @@ test_files:
 - spec/sample_project/models/location.rb
 - spec/sample_project/models/mascot.rb
 - spec/sample_project/models/product.rb
+- spec/sample_project/urls.rb
 - spec/spec_helper.rb
 - spec/url_helper_spec.rb