staticpress 0.3.0 → 0.4.0

data/lib/staticpress/content/resource_content.rb

@@ -1,7 +1,15 @@
 require 'staticpress'
+require 'staticpress/content/static_content'
 
 module Staticpress::Content
   module ResourceContent
+    # FIXME add tests
+    def find_supported_extension(extensionless_path)
+      Staticpress::Content::StaticContent.supported_extensions.detect do |extension|
+        extension.to_sym if Pathname.new("#{extensionless_path}.#{extension}").file?
+      end
+    end
+
     def gather_resources_from(paths)
       paths.map do |child|
         if child.directory?
@@ -14,11 +22,11 @@ module Staticpress::Content
       end.flatten.compact
     end
 
-    def load_resource(route, base, stub)
+    def load_resource(base, stub, params)
       catch :resource do
-        supported_extensions.detect do |extension|
+        Staticpress::Content::StaticContent.supported_extensions.each do |extension|
           path = base + "#{stub}.#{extension}"
-          throw :resource, new(route, path) if path.file?
+          throw :resource, new(params) if path.file?
         end
 
         nil

data/lib/staticpress/content/static_content.rb

@@ -10,15 +10,21 @@ module Staticpress::Content
     def parse_slug(path, base_path)
       path_string = path.to_s
 
-      if supported_extensions.any? { |ext| path_string.end_with? ext.to_s }
-        extensionless_path(path).to_s
+      clean = lambda { |str| str.sub(base_path.to_s, '').sub(/^\//, '') }
+
+      if Staticpress::Content::StaticContent.supported_extensions.any? { |ext| path_string.end_with? ext.to_s }
+        [ clean.call(extensionless_path(path).to_s), path.extname.sub(/^\./, '').to_sym ]
       else
-        path_string
-      end.sub(base_path.to_s, '').sub(/^\//, '')
+        [ clean.call(path_string), nil ]
+      end
     end
 
     def render_partial(locals = {})
       static? ? template_path_content : super
     end
+
+    def self.supported_extensions
+      Tilt.mappings.keys.reject { |mapping| mapping == '' }.map &:to_sym
+    end
   end
 end

data/lib/staticpress/content/tag.rb

@@ -1,19 +1,28 @@
 require 'staticpress'
 require 'staticpress/content/base'
 require 'staticpress/content/collection_content'
-require 'staticpress/route'
+require 'staticpress/content/resource_content'
 
 module Staticpress::Content
   class Tag < Base
     extend CollectionContent
+    extend ResourceContent
+
+    def optional_param_defaults
+      { :number => 1 }
+    end
 
     def sub_content
-      paginate(self.class.content_by_tag[route.params[:name]].sort)[(Integer route.params[:number]) - 1]
+      paginate(self.class.content_by_tag[params[:name]].sort)[params[:number] - 1]
+    end
+
+    def template_path
+      self.class.template_path
     end
 
     def self.all
       tags.map do |tag|
-        find_by_route Staticpress::Route.new(:content_type => self, :name => tag, :number => '1')
+        new :name => tag, :number => '1'
       end
     end
 

data/lib/staticpress/content/theme.rb

@@ -6,12 +6,25 @@ require 'staticpress/route'
 
 module Staticpress::Content
   class Theme < Base
+    include ResourceContent
     include StaticContent
     extend ResourceContent
     extend StaticContent
 
+    attr_reader :extension
+
+    def initialize(params)
+      super
+      @extension = find_supported_extension template_path
+    end
+
     def static?
-      (Staticpress::Theme.new(route.params[:theme]).root + 'assets' + route.params[:asset_type] + route.params[:slug]).file?
+      (Staticpress::Theme.new(params[:theme]).root + 'assets' + params[:asset_type] + params[:slug]).file?
+    end
+
+    def template_path
+      slug = extension ? "#{params[:slug]}.#{extension}" : params[:slug]
+      Staticpress::Theme.new(params[:theme]).root + 'assets' + params[:asset_type] + slug
     end
 
     def self.all
@@ -23,26 +36,11 @@ module Staticpress::Content
         stubs = Staticpress::Route::REGEX_STUBS
         regex = /#{stubs[:theme].regex}\/assets\/#{stubs[:asset_type].regex}\/#{stubs[:slug].regex}/
 
-        if filename_parts = parse_slug(path, (Staticpress.root + 'themes')).match(regex)
-          params = {
-            :content_type => self,
-            :theme => filename_parts[:theme],
-            :asset_type => filename_parts[:asset_type],
-            :slug => filename_parts[:slug]
-          }
-          find_by_route Staticpress::Route.new(params)
+        # FIXME send parse_slug something more intelligent as second parameter
+        if match = regex.match(parse_slug(path, Staticpress.root + 'themes').first)
+          new hash_from_match_data(match)
         end
       end
     end
-
-    def self.find_by_route(route)
-      return nil unless route
-
-      base = Staticpress::Theme.new(route.params[:theme]).root + 'assets' + route.params[:asset_type]
-      path = base + route.params[:slug]
-      return new(route, path) if path.file?
-
-      load_resource route, base, route.params[:slug]
-    end
   end
 end

data/lib/staticpress/helpers.rb

@@ -25,6 +25,10 @@ module Staticpress
       Hash[reply]
     end
 
+    def hash_from_match_data(match)
+      Hash[match.names.map { |match_key| [match_key.to_sym, match[match_key]] }]
+    end
+
     def paginate(range)
       reply = []
 

data/lib/staticpress/route.rb

@@ -1,68 +1,40 @@
 require 'staticpress'
-require 'staticpress/error'
 require 'staticpress/helpers'
-require 'staticpress/site'
 
 module Staticpress
-  class Route
+  module Route
     extend Staticpress::Helpers
-    include Staticpress::Helpers
 
-    RegexStub = Struct.new :regex, :default
+    RegexStub = Struct.new :klass, :regex
 
     REGEX_STUBS = {
-      :asset_type => RegexStub.new(/(?<asset_type>fonts|images|scripts|styles)/),
-      :date => RegexStub.new(/(?<date>\d{4}-\d{2}-\d{2})/),
-      :year => RegexStub.new(/(?<year>\d{4})/),
-      :month => RegexStub.new(/(?<month>\d{2})/),
-      :day => RegexStub.new(/(?<day>\d{2})/),
-      :slug => RegexStub.new(/(?<slug>[0-9a-z\-_\.\/]+)/),
-      :title => RegexStub.new(/(?<title>[0-9a-z\-_]*)/),
-      :name => RegexStub.new(/(?<name>[0-9a-z\-_]*)/),
-      :number => RegexStub.new(/(?<number>\d+)/, '1'),
-      :theme => RegexStub.new(/(?<theme>[0-9a-z\-_]*)/)
+      :asset_type => RegexStub.new(:string,  /(?<asset_type>fonts|images|scripts|styles)/),
+      :date       => RegexStub.new(:date,    /(?<date>\d{4}-\d{2}-\d{2})/),
+      :year       => RegexStub.new(:string,  /(?<year>\d{4})/),
+      :month      => RegexStub.new(:string,  /(?<month>\d{2})/),
+      :day        => RegexStub.new(:string,  /(?<day>\d{2})/),
+      :slug       => RegexStub.new(:string,  /(?<slug>[0-9a-z\-_\.\/]*)/),
+      :title      => RegexStub.new(:string,  /(?<title>[0-9a-z\-_]*)/),
+      :name       => RegexStub.new(:string,  /(?<name>[0-9a-z\-_]*)/),
+      :number     => RegexStub.new(:integer, /(?<number>\d+)/),
+      :theme      => RegexStub.new(:string,  /(?<theme>[0-9a-z\-_]*)/)
     }
 
-    attr_reader :params
-
-    def initialize(params)
-      # TODO apply default values to all params for which a default value exist
-      # TODO ensure all param values are correct type (not always strings)
-      @params = if params.key?(:number)
-        params[:number] ? params : params.merge(:number => REGEX_STUBS[:number].default)
-      else
-        params
+    def self.extract_params(pattern, url_path)
+      if match = regex_for_pattern(pattern).match(url_path)
+        hash_from_match_data match
       end
     end
 
-    def ==(other)
-      other.respond_to?(:params) && (params == other.params)
-    end
-
-    def content
-      params[:content_type].find_by_route self
-    end
-
-    def inspect
-      parts = [
-        "url_path=#{url_path}",
-        "content_type=#{params[:content_type]}"
-      ]
-
-      p = Hash[self.params.clone.sort]
-      p.delete :content_type
-      parts << "params=#{p}"
-
-      "#<#{self.class} #{parts.join ', '}>"
-    end
-
-    def route
-      route_options(route_title).inject(route_pattern) do |reply, (key, value)|
-        reply.gsub /:#{key}/, value.to_s
+    def self.regex_for_pattern(pattern)
+      regex = REGEX_STUBS.inject("^#{pattern}$") do |snip, (key, value)|
+        snip.gsub /:#{key}/, value.regex.source
       end
+
+      Regexp.new regex
     end
 
-    def route_options(title)
+    def self.route_options(title)
       t = Time.now.utc
 
       {
@@ -73,51 +45,5 @@ module Staticpress
         :title => title
       }
     end
-
-    def route_pattern
-      config.routes[type]
-    end
-
-    def url_path
-      return nil unless params[:content_type]
-
-      pattern = config.routes[params[:content_type].type].clone
-
-      # http://www.rubular.com/r/UTV5dNDq6c
-      optional_segment_finder = /\((?<optional_segment>.+)\)\?/
-      pattern.gsub! optional_segment_finder do |match|
-        # http://www.rubular.com/r/LiOup53CI1
-        optional_key = /:(?<optional_key>[0-9a-z_]+)/.match(match)[:optional_key].to_sym
-        optional_segment_finder.match(match)[:optional_segment] unless params[optional_key] == REGEX_STUBS[optional_key].default
-      end
-
-      REGEX_STUBS.keys.inject(pattern) do |p, key|
-        p.gsub /:#{key}/, params[key].to_s
-      end
-    end
-    alias :to_s :url_path
-
-    def self.from_url_path(url_path)
-      catch :route do
-        Staticpress::Site.content_types.each do |content_type|
-          if match = regex_for_pattern(config.routes[content_type.type]).match(url_path)
-            params = { :content_type => content_type }
-            match.names.each { |match_key| params[match_key.to_sym] = match[match_key] }
-            route = new params
-            throw :route, route if route.content
-          end
-        end
-
-        nil
-      end
-    end
-
-    def self.regex_for_pattern(pattern)
-      regex = REGEX_STUBS.inject("^#{pattern}$") do |snip, (key, value)|
-        snip.gsub /:#{key}/, value.regex.source
-      end
-
-      Regexp.new regex
-    end
   end
 end

data/lib/staticpress/server.rb

@@ -9,9 +9,7 @@ module Staticpress
     end
 
     def call(env)
-      content = @site.find_content_by_url_path env['REQUEST_PATH']
-
-      if content
+      if content = @site.find_content_by_env(env)
         [ 200, { 'Content-Type' => content.content_type }, [ content.render ] ]
       else
         [ 404, {}, [] ]

data/lib/staticpress/site.rb

@@ -9,10 +9,19 @@ require 'staticpress/content/post'
 require 'staticpress/content/theme'
 require 'staticpress/helpers'
 require 'staticpress/metadata'
-require 'staticpress/route'
 
 module Staticpress
   class Site
+    # ordered by priority
+    CONTENT_TYPES = [
+      Staticpress::Content::Page,
+      Staticpress::Content::Post,
+      Staticpress::Content::Index,
+      Staticpress::Content::Category,
+      Staticpress::Content::Tag,
+      Staticpress::Content::Theme
+    ]
+
     include Staticpress::Helpers
 
     attr_reader :directory
@@ -22,12 +31,18 @@ module Staticpress
     end
 
     def all_content
-      self.class.content_types.map(&:all).flatten
+      CONTENT_TYPES.map(&:all).flatten
     end
 
-    def find_content_by_url_path(url_path)
-      route = Staticpress::Route.from_url_path url_path
-      route.content if route
+    def find_content_by_env(env)
+      catch :content do
+        CONTENT_TYPES.detect do |content_type|
+          content = content_type.find_by_url_path env['REQUEST_PATH']
+          throw :content, content if content && content.exist?
+        end
+
+        nil
+      end
     end
 
     def meta
@@ -42,16 +57,5 @@ module Staticpress
       FileUtils.rm_r destination if destination.directory?
       all_content.each &:save
     end
-
-    def self.content_types
-      [
-        Staticpress::Content::Index,
-        Staticpress::Content::Category,
-        Staticpress::Content::Tag,
-        Staticpress::Content::Page,
-        Staticpress::Content::Post,
-        Staticpress::Content::Theme
-      ]
-    end
   end
 end

data/lib/staticpress/version.rb

@@ -2,7 +2,7 @@ module Staticpress
   # TODO figure out how to implement Gem::Version properly
   class Version
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     PATCH = 0
 
     def self.to_s

data/tests/staticpress/configuration_test.rb

@@ -0,0 +1,4 @@
+require_relative '../test_case'
+
+class ConfigurationTest < TestCase
+end

data/tests/staticpress/content/base_test.rb

@@ -0,0 +1,271 @@
+require_relative '../../test_case'
+
+require 'staticpress/content/base'
+require 'staticpress/content/category'
+require 'staticpress/content/index'
+require 'staticpress/content/page'
+require 'staticpress/content/post'
+require 'staticpress/content/tag'
+require 'staticpress/content/theme'
+
+class ContentBaseTest < TestCase
+  let(:category) { Staticpress::Content::Category.new :name => 'programming' }
+  let(:category_1) { Staticpress::Content::Category.new(:name => 'programming', :number => '1') }
+  let(:category_2) { Staticpress::Content::Category.new(:name => 'programming', :number => '2') }
+
+  let(:index) { Staticpress::Content::Index.new :number => 1 }
+  let(:index_2) { Staticpress::Content::Index.new :number => 2 }
+
+  let(:page) { Staticpress::Content::Page.new(:slug => 'about') }
+  let(:second_page) { Staticpress::Content::Page.new :slug => 'contact' }
+  let(:page_root) { Staticpress::Content::Page.new :slug => '' }
+  let(:style_2) { Staticpress::Content::Page.new :slug => 'style2.css' }
+  let(:page_nested) { Staticpress::Content::Page.new :slug => 'foo/bar/baz' }
+  let(:static_bin) { Staticpress::Content::Page.new :slug => 'ruby.png' }
+  let(:static_txt) { Staticpress::Content::Page.new :slug => 'plain.txt' }
+  let(:page_fake) { Staticpress::Content::Page.new :slug => 'i/dont/exist' }
+
+  let(:post) { Staticpress::Content::Post.new(:year => '2011', :month => '07', :day => '20', :title => 'hello') }
+
+  let(:tag) { Staticpress::Content::Tag.new :name => 'charlotte' }
+
+  let(:asset_style) { Staticpress::Content::Theme.new :theme => 'test_theme', :asset_type => 'styles', :slug => 'all' }
+  let(:asset_script) { Staticpress::Content::Theme.new :theme => 'test_theme', :asset_type => 'scripts', :slug => 'application.js' }
+
+  def test__equalsequals
+    assert_operator category, :==, Staticpress::Content::Category.new(:name => 'programming')
+    refute_operator category, :==, nil
+
+    assert_operator index, :==, Staticpress::Content::Index.new(:number => 1)
+    refute_operator index, :==, index_2
+    refute_operator index, :==, nil
+
+    assert_operator page, :==, Staticpress::Content::Page.new(:slug => 'about')
+    refute_operator page, :==, second_page
+    refute_operator page, :==, nil
+    assert_operator static_bin, :==, Staticpress::Content::Page.new(:slug => 'ruby.png')
+    refute_operator static_bin, :==, nil
+    refute_operator static_bin, :==, static_txt
+
+    assert_operator post, :==, Staticpress::Content::Post.new(:year => '2011', :month => '07', :day => '20', :title => 'hello')
+    refute_operator post, :==, nil
+
+    assert_operator tag, :==, Staticpress::Content::Tag.new(:name => 'charlotte')
+    refute_operator tag, :==, nil
+
+    assert_operator asset_style, :==, Staticpress::Content::Theme.new(:theme => 'test_theme', :asset_type => 'styles', :slug => 'all')
+    refute_operator asset_style, :==, nil
+
+    refute_operator Staticpress::Content::Category.new(:name => 'programming'), :==, Staticpress::Content::Tag.new(:name => 'programming')
+  end
+
+  def test_content_type
+    assert_equal 'text/html', page.content_type
+    assert_equal 'text/css', style_2.content_type
+    assert_equal 'image/png', static_bin.content_type
+    assert_equal 'text/plain', static_txt.content_type
+  end
+
+  def test_exist?
+    assert category.exist?, "#{category} does not exist"
+    assert index.exist?, "#{index} does not exist"
+
+    assert page.exist?, "#{page} does not exist"
+    assert second_page.exist?, "#{second_page} does not exist"
+    assert static_bin.exist?, "#{static_bin} does not exist"
+    assert static_txt.exist?, "#{static_txt} does not exist"
+    assert page_root.exist?, "#{page_root} does not exist"
+
+    assert post.exist?, "#{post} does not exist"
+    assert tag.exist?, "#{tag} does not exist"
+
+    assert asset_style.exist?, "#{asset_style} does not exist"
+    assert asset_script.exist?, "#{asset_script} does not exist"
+
+    refute page_fake.exist?, "#{page_fake} exists"
+  end
+
+  def test_find_by_url_path
+    assert_equal category, Staticpress::Content::Category.find_by_url_path('/category/programming')
+    assert_equal index, Staticpress::Content::Index.find_by_url_path('/')
+
+    assert_equal page_root, Staticpress::Content::Page.find_by_url_path('/')
+    assert_equal page, Staticpress::Content::Page.find_by_url_path('/about')
+    assert_equal static_bin, Staticpress::Content::Page.find_by_url_path('/ruby.png')
+
+    assert_equal post, Staticpress::Content::Post.find_by_url_path('/2011/07/20/hello')
+    assert_equal tag, Staticpress::Content::Tag.find_by_url_path('/tag/charlotte')
+
+    assert_equal asset_style, Staticpress::Content::Theme.find_by_url_path('/assets/test_theme/styles/all')
+    assert_equal asset_script, Staticpress::Content::Theme.find_by_url_path('/assets/test_theme/scripts/application.js')
+
+    assert_nil Staticpress::Content::Theme.find_by_url_path(nil)
+  end
+
+  def test_full_title
+    assert_equal 'Foo -> Bar -> Baz | Test Blog', page_nested.full_title
+  end
+
+  def test_output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'about' + 'index.html'), page.output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'index.html'), page_root.output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'style2.css'), style_2.output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'ruby.png'), static_bin.output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'plain.txt'), static_txt.output_path
+    assert_equal (Staticpress.blog_path + 'public' + '2011' + '07' + '20' + 'hello' + 'index.html'), post.output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'assets' + 'test_theme' + 'styles' + 'all'), asset_style.output_path
+    assert_equal (Staticpress.blog_path + 'public' + 'assets' + 'test_theme' + 'scripts' + 'application.js'), asset_script.output_path
+  end
+
+  def test_params
+    expected = { :name => 'charlotte', :number => 1 }
+    assert_equal expected, tag.params
+    assert_equal expected, Staticpress::Content::Tag.new(:name => 'charlotte', :number => nil).params
+    assert_equal expected, Staticpress::Content::Tag.new(:name => 'charlotte', :number => 1).params
+    assert_equal expected, Staticpress::Content::Tag.new(:name => 'charlotte', :number => '1').params
+  end
+
+  def test_raw
+    assert_equal '= partial :list_posts, :posts => page.sub_content', category.raw
+
+    assert_equal 'in page', page.raw
+    assert_equal "in page\n\nin page", second_page.raw
+    assert_equal 'this file intentionally left blank', static_txt.raw
+
+    assert_equal 'in post', post.raw
+    assert_equal '= partial :list_posts, :posts => page.sub_content', tag.raw
+    assert_equal '@import "compass/reset/utilities"', asset_style.raw
+
+    expected = <<-JS
+(function ($) {
+  $(document).ready(function () {
+  });
+})(jQuery);
+    JS
+    assert_equal expected.strip, asset_script.raw
+  end
+
+  def test_render
+    expected_page = <<-HTML
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>About | Test Blog</title>
+  </head>
+  <body>
+    <p>in page</p>
+  </body>
+</html>
+    HTML
+    assert_equal expected_page, page.render
+
+    expected_style2 = <<-CSS
+body{color:green}
+    CSS
+    assert_equal expected_style2, style_2.render
+
+    assert_equal 'this file intentionally left blank', static_txt.render
+    refute_raises(Sass::SyntaxError) { asset_style.render }
+
+    expected = <<-SASS
+    SASS
+    assert_equal expected, asset_style.render
+
+    expected = <<-JS
+(function ($) {
+  $(document).ready(function () {
+  });
+})(jQuery);
+    JS
+    assert_equal expected, asset_script.render
+  end
+
+  def test_render_partial
+    assert_equal "<p>in page</p>\n", page.render_partial
+    assert_equal "<p>in page</p>\n\n<p>in page</p>\n", second_page.render_partial
+
+    expected_style2 = <<-CSS
+body{color:green}
+    CSS
+    assert_equal expected_style2, style_2.render_partial
+
+    assert_equal 'this file intentionally left blank', static_txt.render_partial
+    assert_equal "<p>in post</p>\n", post.render_partial
+
+    refute_raises(Sass::SyntaxError) { asset_style.render_partial }
+    expected = <<-SASS
+    SASS
+
+    assert_equal expected, asset_style.render_partial
+    expected = <<-JS
+(function ($) {
+  $(document).ready(function () {
+  });
+})(jQuery);
+    JS
+    assert_equal expected, asset_script.render_partial
+  end
+
+  def test_save
+    static_bin.save
+    assert_equal static_bin.template_path.binread, static_bin.output_path.binread
+
+    static_txt.save
+    assert_equal static_txt.template_path.read, static_txt.output_path.read
+  end
+
+  def test_template_engine_options
+    expected = Compass.sass_engine_options.merge :line_comments => false, :style => :compressed
+    assert_eql expected, asset_style.template_engine_options
+    assert_equal({}, asset_script.template_engine_options)
+  end
+
+  def test_template_type
+    assert_equal :markdown, page.template_type
+    assert_equal :sass, asset_style.template_type
+    assert_equal :js, asset_script.template_type
+  end
+
+  def test_title
+    assert_equal 'Foo -> Bar -> Baz', page_nested.title
+  end
+
+  def test_to_s
+    assert_equal '#<Staticpress::Content::Category url_path=/category/programming, params={:name=>"programming", :number=>1}>', category.to_s
+    assert_equal '#<Staticpress::Content::Category url_path=/category/programming, params={:name=>"programming", :number=>1}>', Staticpress::Content::Category.new(:name => 'programming', :number => nil).to_s
+
+    assert_equal '#<Staticpress::Content::Index url_path=/, params={:number=>1}>', index.to_s
+    assert_equal '#<Staticpress::Content::Index url_path=/page/2, params={:number=>2}>', index_2.to_s
+
+    assert_equal '#<Staticpress::Content::Page url_path=/, params={:slug=>""}>', page_root.to_s
+    assert_equal '#<Staticpress::Content::Page url_path=/about, params={:slug=>"about"}>', page.to_s
+    assert_equal '#<Staticpress::Content::Page url_path=/ruby.png, params={:slug=>"ruby.png"}>', static_bin.to_s
+
+    assert_equal '#<Staticpress::Content::Post url_path=/2011/07/20/hello, params={:day=>"20", :month=>"07", :title=>"hello", :year=>"2011"}>', post.to_s
+
+    assert_equal '#<Staticpress::Content::Tag url_path=/tag/charlotte, params={:name=>"charlotte", :number=>1}>', tag.to_s
+
+    assert_equal '#<Staticpress::Content::Theme url_path=/assets/test_theme/styles/all, params={:asset_type=>"styles", :slug=>"all", :theme=>"test_theme"}>', asset_style.to_s
+  end
+
+  def test_url_path
+    assert_equal '/category/programming', category.url_path
+    assert_equal '/category/programming', category_1.url_path
+    assert_equal '/category/programming/page/2', category_2.url_path
+
+    assert_equal '/', index.url_path
+    assert_equal '/page/2', index_2.url_path
+
+    assert_equal '/', page_root.url_path
+    assert_equal '/about', page.url_path
+    assert_equal '/contact', second_page.url_path
+    assert_equal '/ruby.png', static_bin.url_path
+    assert_equal '/plain.txt', static_txt.url_path
+
+    assert_equal '/2011/07/20/hello', post.url_path
+
+    assert_equal '/2011/07/20/hello', post.url_path
+    assert_equal '/tag/charlotte', tag.url_path
+    assert_equal '/assets/test_theme/styles/all', asset_style.url_path
+  end
+end