rayo 0.1.0 → 0.2.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alexey Noskov
+
+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,154 @@
+= Rayo
+
+Rayo is a CMS based on lightweight {Sinatra framework}[http://www.sinatrarb.com/] and {Radius gem}[http://radius.rubyforge.org/]. It was inspired by {Radiant}[http://radiantcms.org/], very powerful ROR-based CMS.
+
+<b>Caution! The project in a very early stage of development!</b>
+
+== Installation
+
+Install rayo gem (recommended):
+
+  sudo gem install irwi
+
+Or clone it:
+
+  git clone git://github.com/alno/rayo
+
+== Rack application
+
+To create basic Rayo-based application all you need is Rackup file (config.ru) with content similar to:
+
+  require '../rayo/lib/rayo.rb'
+
+  class Application < Rayo::Application
+
+    configure do |c|
+      c.content_dir = File.join( File.dirname(__FILE__), 'content' ) # Content location
+      c.languages = ['en','ru'] # Supported languages
+    end
+
+  end
+
+  run Application
+
+== Content structure
+
+Here we create our application by extending Rayo::Application class, set content directory location and supported languages.
+Content should be placed in <tt>content</tt> subdirectories similar to following scheme:
+
+  content
+  + layouts
+    + base.html
+  + snippets
+    + footer.html
+  + pages
+    + index.yml
+    + index.html
+    + index.sidebar.ru.html
+    + index.sidebar.en.html
+    + section.yml
+    + section.html
+    + section
+      + subpage.yml
+      + subpage.html
+
+There are example layout, snippet and 3 pages: <tt>index</tt>, <tt>section</tt> and <tt>section/subpage</tt>. Index page contains additional page part <tt>sidebar</tt>, wchih is translated to English and Russian.
+It should be noticed what each page have corresponding .yml file. This file contains page properties which should be used in page rendering.
+
+=== Generic pages
+
+You may create generic pages which are rendered for a set of different paths. For example to create archive pages in blog you may use:
+
+  pages
+  + 2010
+  | + 09
+  |   + my-first-post.yml
+  |   + my-first-post.html
+  + %year.yml
+  + %year.html
+  + %year
+    + %month.yml
+    + %month.html
+
+== Content formatting
+
+=== Built-In Tags
+
+=== Filters
+
+== Configuration
+
+Configuration options are provided in <tt>configure</tt> block in application class:
+
+  configure do |c|
+    c.content_dir = File.join( File.dirname(__FILE__), 'content' ) # Content location
+    c.languages = ['en','ru'] # Supported languages
+  end
+
+Besides of these options you append your filters for processing content (after expanding radius tags):
+
+  c.add_filter 'textile' do |source|
+    RedCloth.new( source ).to_html
+  end
+
+Also, you may define modules which contain tag definitions:
+
+  module MyTags
+
+    include Rayo::Taggable
+
+    tag 'hello' do
+      'Hello world'
+    end
+
+    tag 'repeat' do |tag|
+      number = (tag.attr['times'] || '1').to_i
+      result = ''
+      number.times { result << tag.expand }
+      result
+    end
+
+  end
+
+And register it:
+
+  c.add_tags MyTags
+
+=== Multidomain applications
+
+Sometimes you may want to serve different domains with one application sharing layouts and snippets. Rayo has built-in support for this scenario. All you need is to create subdirectories in pages for different domains and add some lines to <tt>configure</tt> block:
+
+To serve 'first.example.com' with pages from <tt>content/pages/first.example.com</tt> directory:
+
+  c.add_domain 'first.example.com'
+
+To serve 'second.example.com' or 'www.second.example.com' with pages from <tt>content/pages/second</tt> directory:
+
+  c.add_domain 'second.', /^(www\.)?second\.example\.com$/
+
+With both lines corresponding directory structure should be:
+
+  content
+  + layouts
+  + snippets
+  + pages
+    + first.example.com
+    + second
+
+That's all you need to build multi-domain application.
+
+== Planned features
+
+* Support for sites without I18n
+* Support for different page formats
+* Drop-in tag libary support
+* Support for pages without .yml
+* Generator which creates a set of static pages from content structure
+
+== Contributors
+
+* Alexey Noskov (http://github.com/alno)
+
+Feel free to add yourself when you add new features.
+
+Copyright (c) 2010 Alexey Noskov, released under the MIT license

data/lib/rayo/application.rb

@@ -7,7 +7,7 @@ class Rayo::Application < Sinatra::Base
 
   class << self
 
-    attr_accessor :config # Application configuration object
+    attr_accessor :config
 
     # Configure application
     def configure
@@ -20,35 +20,41 @@ class Rayo::Application < Sinatra::Base
     self.class.config
   end
 
-  get '/' do
-    redirect_to_lang '' # Root page
-  end
+  get '/*' do |path|
+    cfg = config.domain( request.host ) # Config for current host
 
-  get '*/' do |path|
-    redirect path # Remove trailing slashes
-  end
+    if cfg
+      path = path.split '/' # Split path into segments
 
-  get '/*' do |path|
-    path = path.split '/' # Split path into segments
+      empty_segments_found = path.reject! {|e| e.empty? } # Clear path and detect empty segments
 
-    return redirect_to_lang path unless config.languages.include? path.first
+      return redirect_to_lang path unless config.languages.include? path.first
+      return redirect '/' + path.join('/') if empty_segments_found
 
-    lang = path.shift # Determine language
-    storage = Rayo::Storage.new( config, lang ) # Page storage
-    page = storage.page( path ) # Find page by path
-    page = storage.status_page( path, 404 ) unless page && page.file # Render 404 page if there are no page, or there are no file
+      lang = path.shift # Determine language
 
-    [ page[:status], page.render ] # Return page status and content
+      storage = create_storage( cfg ) # Page storage
+      page = storage.page( lang, path ) # Find page by path
+      page = storage.status_page( lang, path, 404 ) unless page && page.file # Render 404 page if there are no page, or there are no file
+
+      [ page[:status], page.render ] # Return page status and content
+    else
+      [ 404, "Page not found" ]
+    end
   end
 
   private
 
+  def create_storage( cfg )
+    Rayo::Storage.new( cfg )
+  end
+
   def select_language
     config.languages.first
   end
 
   def redirect_to_lang( path )
-    redirect [select_language, *path].join '/'
+    redirect '/' + [ select_language, *path].join('/')
   end
 
 end

data/lib/rayo/config.rb

@@ -14,6 +14,7 @@ class Rayo::Config
     @page_exts = ['.yml']
 
     @filters = {}
+    @domains = []
 
     # Default filters
     add_filter('html'){|source| source }
@@ -28,15 +29,28 @@ class Rayo::Config
   end
 
   # Add tags defined in module
+  #
+  # @param [Module] module defining tags to use
   def add_tags( tag_module )
     @tagger.extend tag_module
   end
 
   # Add filter
+  #
+  # @param [String,Symbol] file extension
+  # @param [Proc] filter proc which accepts source and return it in processed form
   def add_filter( ext, &filter )
     @filters[".#{ext}"] = filter
   end
 
+  # Add domain
+  #
+  # @param [String] domain name
+  # @param [Regexp,String] host pattern
+  def add_domain( name, exp = nil )
+    @domains << Rayo::Config::Domain.new( self, name, exp )
+  end
+
   # Create new object containing all defined tags
   def create_tagger
     @tagger.clone
@@ -54,4 +68,14 @@ class Rayo::Config
     @filters[ ext.to_s ]
   end
 
+  def domain( host )
+    if @domains.empty?
+      self # No multidomain support
+    else
+      @domains.find { |domain| domain.matches? host }
+    end
+  end
+
 end
+
+require File.join(File.dirname(__FILE__), 'config/domain.rb')

data/lib/rayo/config/domain.rb

@@ -0,0 +1,27 @@
+require 'forwardable'
+
+class Rayo::Config::Domain
+
+  extend Forwardable
+
+  def_delegators :@parent, :create_tagger, :languages, :page_exts, :renderable_exts, :filter
+
+  def initialize( parent, name, exp )
+    @parent = parent
+    @name = name
+    @exp = exp || Regexp.new( "^#{Regexp.quote( name )}\.?$" )
+  end
+
+  def matches?( host )
+    host =~ @exp
+  end
+
+  def directory( content_type )
+    if content_type == :pages
+      File.join( @parent.directory( content_type ), @name )
+    else
+      @parent.directory( content_type )
+    end
+  end
+
+end

data/lib/rayo/models/page.rb

@@ -6,42 +6,59 @@ require File.join(File.dirname(__FILE__), '..', 'tag_context.rb')
 
 class Rayo::Models::Page
 
-  attr_reader :storage, :parent, :path
+  attr_reader :storage, :parent, :lang, :path
 
-  def initialize( storage, parent, path )
+  def initialize( storage, parent, lang, path )
     @storage = storage
     @parent = parent
+    @lang = lang
     @path = path
   end
 
   def descendant( relative_path )
-    relative_path.inject( self ) {|page,slug| page.child( slug ) }
+    relative_path.inject( self ) do |page,slug|
+      return nil unless page
+
+      page.child( slug )
+    end
   end
 
   def children
-    @children ||= @storage.find_pages( directories ).map{|name| child( name ) }
+    @children ||= @storage.find_pages( directories, @lang ).map{|name| child( name ) }
   end
 
   def child( slug )
     @children_cache ||= {}
     return @children_cache[ slug ] if @children_cache.include? slug
 
-    page = Rayo::Models::Page.new( @storage, self, @path + [slug] )
+    page = Rayo::Models::Page.new( @storage, self, @lang, @path + [slug] )
     page = nil if page.file.nil? && page.directories.empty?
 
     @children_cache[ slug ] = page
   end
 
   def directories
-    @directories ||= @storage.find_page_dirs( @parent.directories, @path.last )
+    @directories ||= @storage.find_page_dirs( @parent.directories, @lang, @path.last )
   end
 
   def file
-    @file ||= @storage.find_page_file( @parent.directories, @path.last )
+    @file ||= @storage.find_page_file( @parent.directories, @lang, @path.last )
   end
 
   def parts
-    @parts ||= file ? @storage.find_page_parts( file ) : {}
+    @parts ||= file ? @storage.find_page_parts( file, @lang ) : {}
+  end
+
+  def find_part( part_name, inherit = false )
+    page = self
+    part = self.parts[part_name]
+
+    while inherit && !part && page.parent do
+      page = page.parent
+      part = page.parts[part_name]
+    end
+
+    part
   end
 
   def params
@@ -68,7 +85,7 @@ class Rayo::Models::Page
   end
 
   def layout
-    @layout ||= @storage.layout( context['layout'] )
+    @layout ||= @storage.layout( @lang, context['layout'] )
   end
 
   def []( key )
@@ -88,7 +105,7 @@ class Rayo::Models::Page
   private
 
   def load_context( filename )
-    YAML::load( Erubis::Eruby.new( File.read( filename ) ).result( params ) )
+    YAML::load( Erubis::Eruby.new( @storage.load( filename ) ).result( params ) )
   end
 
 end

data/lib/rayo/models/renderable.rb

@@ -1,15 +1,17 @@
 class Rayo::Models::Renderable
 
+  attr_reader :storage
   attr_reader :file
   attr_reader :filter
 
-  def initialize( file, filter )
+  def initialize( storage, file, filter )
+    @storage = storage
     @file = file
     @filter = filter
   end
 
   def source
-    @source ||= File.read( file )
+    @source ||= @storage.load( file )
   end
 
   def render( parser )

data/lib/rayo/models/root_page.rb

@@ -3,8 +3,8 @@ require File.join(File.dirname(__FILE__), 'status_page.rb')
 
 class Rayo::Models::RootPage < Rayo::Models::Page
 
-  def initialize( storage )
-    super( storage, nil, [] )
+  def initialize( storage, lang )
+    super( storage, nil, lang, [] )
   end
 
   def directories
@@ -12,7 +12,7 @@ class Rayo::Models::RootPage < Rayo::Models::Page
   end
 
   def file
-    @file ||= @storage.find_page_file( directories, 'index' )
+    @file ||= @storage.find_page_file( directories, @lang, 'index' )
   end
 
   def params

data/lib/rayo/models/status_page.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'page.rb')
 class Rayo::Models::StatusPage < Rayo::Models::Page
 
   def initialize( storage, root, path, status )
-    super( storage, root, path )
+    super( storage, root, root.lang, path )
 
     @status = status
   end
@@ -13,14 +13,14 @@ class Rayo::Models::StatusPage < Rayo::Models::Page
   end
 
   def file
-    @file ||= @storage.find_page_file( @parent.directories, @status.to_s )
+    @file ||= @storage.find_page_file( @parent.directories, @lang, @status.to_s )
   end
 
   def context
     return @context if @context
 
     @context = @parent ? @parent.context.merge({ 'status' => @status }) : { 'status' => @status }
-    @context.merge! load_context( file + '.yml' ) if file
+    @context.merge! load_context( file ) if file
     @context
   end
 

data/lib/rayo/storage.rb

@@ -5,105 +5,134 @@ class Rayo::Storage
 
   attr_reader :config
 
-  def initialize( config, lang )
+  def initialize( config )
     @config = config
 
-    @lang = lang
-    @lang_prefix = '.' + lang
-
+    @roots = {}
     @layouts = {}
     @snippets = {}
   end
 
-  def snippet( name )
-    @snipetts[name.to_s] ||= find_renderable_file( :snippets, name.to_s ) || raise( "Snippet '#{name}' not found" )
+  def snippet( lang, name )
+    @snippets["#{lang}|#{name}"] ||= find_renderable( :snippets, lang, name.to_s ) || raise( "Snippet '#{name}' not found" )
   end
 
-  def layout( name )
-    @layouts[name.to_s] ||= find_renderable( :layouts,  name.to_s ) || raise( "Layout '#{name}' not found" )
+  def layout( lang, name )
+    @layouts["#{lang}|#{name}"] ||= find_renderable( :layouts, lang, name.to_s ) || raise( "Layout '#{name}' not found" )
   end
 
-  def root_page
-    @root_page ||= Rayo::Models::RootPage.new( self )
+  # Retrieves root page for specific language
+  #
+  # @param [String,Symbol] page language
+  # @return [Rayo::Models::RootPage] root page
+  def root_page( lang )
+    @roots[ lang.to_s ] ||= Rayo::Models::RootPage.new( self, lang.to_s )
   end
 
-  def page( path )
-    root_page.descendant( path )
+  # Retrieves page for specific language and path
+  #
+  # @param [String,Symbol] page language
+  # @param [Array<String>] page path
+  # @return [Rayo::Models::Page] page
+  def page( lang, path )
+    root_page( lang ).descendant( path )
   end
 
-  def status_page( path, status )
-    Rayo::Models::StatusPage.new( self, root_page, path, status )
+  # Retrieves status page for specific language and path
+  #
+  # @param [String,Symbol] page language
+  # @param [Array<String>] page path
+  # @return [Rayo::Models::StatusPage] status page
+  def status_page( lang, path, status )
+    Rayo::Models::StatusPage.new( self, root_page( lang ), path, status )
   end
 
-  def find_renderable( type, name )
-    if file = find_file( [config.directory( type )], name, config.renderable_exts )
+  def find_renderable( type, lang, name )
+    if file = find_file( [config.directory( type )], lang, name, config.renderable_exts )
       renderable( file, File.extname( file ) )
     end
   end
 
-  def find_page_file( dirs, slug )
-    find_file( dirs, slug, config.page_exts )
+  def find_page_file( dirs, lang, slug )
+    find_file( dirs, lang, slug, config.page_exts )
   end
 
-  def find_page_dirs( dirs, slug )
-    find_files dirs, slug, ['']
+  def find_page_dirs( dirs, lang, slug )
+    find_files( dirs, lang, slug, [''] )
   end
 
-  def find_pages( dirs )
-    find_files dirs, '*', config.page_exts + ['']
+  def find_pages( dirs, lang )
+    res = []
+    glob_files dirs, lang, '*', config.page_exts + [''] do |file,base,ext|
+      elems = base.split('.')
+      elem_name = elems[0]
+      elem_lang = elems[1]
+
+      res << elem_name unless elem_name[0..0] == '%' || (dirs == ([ @config.directory :pages ]) && (elem_name == 'index' || elem_name =~ /^\d+$/ )) || (elem_lang && elem_lang != lang)
+    end
+    res.uniq
   end
 
-  def find_page_parts( page_file )
+  def find_page_parts( page_file, lang )
     parts = {}
-    page_file_base = File.basename( page_file, File.extname( page_file ) )
-    glob_files File.dirname( page_file ), page_file_base + '*', config.renderable_exts do |file,base,ext|
+    page_file_base = File.basename( page_file ).split('.').first
+    glob_files File.dirname( page_file ), lang, page_file_base + '*', config.renderable_exts do |file,base,ext|
       elems = base.split('.')
 
       if elems.shift == page_file_base # Remove base (slug or variable)
         if elems.size == 0 # There are no part name and language
           parts[ 'body'   ] ||= renderable( file, ext )
         elsif elems.size == 1 # There are no language or no part name
-          parts[ elems[0] ] ||= renderable( file, ext )
-          parts[ 'body'   ]   ||= renderable( file, ext ) if elems[1] == @lang
+          if elems[0] == lang
+            parts[ 'body'   ] ||= renderable( file, ext )
+          else
+            parts[ elems[0] ] ||= renderable( file, ext )
+          end
         else
-          parts[ elems[0] ] ||= renderable( file, ext ) if elems[1] == @lang
+          parts[ elems[0] ] ||= renderable( file, ext ) if elems[1] == lang
         end
       end
     end
     parts
   end
 
+  def load( file )
+    File.read( file )
+  end
+
   private
 
   def renderable( file, ext )
-    Rayo::Models::Renderable.new( file, config.filter( ext ) || raise( "Filter for '#{ext} not found" ) )
+    Rayo::Models::Renderable.new( self, file, config.filter( ext ) || raise( "Filter for '#{ext} not found" ) )
   end
 
   # Find first file with given name (or variable) and extension from given set
-  def find_file( dirs, name, exts )
-    glob_files( dirs, name, exts ) { |file,base,ext| return file }
+  def find_file( dirs, lang, name, exts )
+    glob_files( dirs, lang, name, exts ) { |file,base,ext| return file }
     nil
   end
 
   # Find files with given name (or variable) and extension from given set
-  def find_files( dirs, name, exts )
+  def find_files( dirs, lang, name, exts )
     results = []
-    glob_files( dirs, name, exts ) { |file,base,ext| results << file }
+    glob_files( dirs, lang, name, exts ) { |file,base,ext| results << file }
     results
   end
 
-  def glob_files( dirs, name, exts, &block )
-    glob dirs, name + @lang_prefix, //, exts, &block # Search with given name and language
+  def glob_files( dirs, lang, name, exts, &block )
+    lang_prefix = "." + lang
+
+    glob dirs, name + lang_prefix, //, exts, &block # Search with given name and language
     glob dirs, name, //, exts, &block # Search with given name without language
-    glob dirs, '%*' + @lang_prefix, /^%.+\.#{@lang}$/, exts, &block # Search with variable and language
+    glob dirs, '%*' + lang_prefix, /^%.+\.#{lang}$/, exts, &block # Search with variable and language
     glob dirs, '%*',  /^%.+$/, exts, &block # Search with variable without language
   end
 
   def glob( dirs, mask_wo_ext, base_regexp, exts )
-    mask = mask_wo_ext + ext_mask( exts )
+    mask = mask_wo_ext + ext_mask( mask_wo_ext, exts )
 
     dirs.each do |dir|
-      Dir.glob File.join( dir, mask ) do |file|
+      dir_glob File.join( dir, mask ) do |file|
         ext = File.extname( file )
         base = File.basename( file, ext )
 
@@ -112,7 +141,11 @@ class Rayo::Storage
     end
   end
 
-  def ext_mask( exts )
+  def dir_glob( mask, &block )
+    Dir.glob mask, &block
+  end
+
+  def ext_mask( mask_wo_ext, exts )
     if exts.size == 1 # Only one extension
       exts.first # Use it in mask
     elsif !exts.include? '' # No empty extension

data/lib/rayo/tag_context.rb

@@ -8,6 +8,7 @@ class Rayo::TagContext < Radius::Context
     @page = page
 
     globals.page = @page
+    globals.storage = @page.storage
 
     tagger = @page.storage.config.create_tagger
     tagger.methods.each do |name|
@@ -15,4 +16,20 @@ class Rayo::TagContext < Radius::Context
     end
   end
 
+  def render_tag(name, attributes = {}, &block)
+    super
+  rescue Exception => e
+    error("#{e.message} <pre>#{e.backtrace.join("\n")}</pre>")
+  end
+
+  def tag_missing(name, attributes = {}, &block)
+    super
+  rescue Radius::UndefinedTagError => e
+    error("#{e.message} <pre>#{e.backtrace.join("\n")}</pre>")
+  end
+
+  def error( text )
+    "<strong class=\"error\">#{text}</strong>"
+  end
+
 end

data/lib/rayo/tags/content_tags.rb

@@ -3,44 +3,55 @@ module Rayo::Tags::ContentTags
   include Rayo::Taggable
 
   tag 'content' do |tag|
-    part_name = tag.attr['part'] || 'body'
-    inherit = tag.attr['inherit'] == 'true'
-
-    page = tag.locals.page
-    part = page.parts[part_name]
-
-    while inherit && !part && page.parent do
-      page = page.parent
-      part = page.parts[part_name]
-    end
-
-    if part
+    if part = find_part( tag )
       part.render( tag.globals.page.parser )
     else
-      error "No part '#{part_name}' found for page '#{tag.locals.page.path}'"
+      error "No part '#{tag.attr['part'] || 'body'}' found for page '#{tag.locals.page.path.join('/')}'"
     end
   end
 
+  tag 'if_content' do |tag|
+    find_part( tag ) && tag.expand || ''
+  end
+
   tag 'content_for_layout' do |tag|
-    send 'tag:content', tag
+    tag.globals.content_stack ||= [] # Prepare the stacks
+    tag.globals.content_stack.pop || send( 'tag:content', tag )
   end
 
-  tag 'snippet' do |tag|
-    number = (tag.attr['times'] || '1').to_i
-    result = ''
-    number.times { result << tag.expand }
-    result
+  tag 'layout' do |tag|
+    if name = tag.attr['name'].strip
+      tag.globals.layout_stack ||= [] # Prepare layout stack
+      tag.globals.content_stack ||= [] # Prepare content stack
+
+      if layout = tag.globals.storage.layout( tag.globals.page.lang, name )
+        tag.globals.layout_stack << name # Track this layout on the stack
+        tag.globals.content_stack << tag.expand # Save contents of inside_layout for later insertion
+
+        layout.render( tag.globals.page.parser )
+      else
+        error "Parent layout '#{name.strip}' not found for 'layout' tag"
+      end
+    else
+      error "'layout' tag must contain a 'name' attribute"
+    end
   end
 
-  tag 'hello' do
-     'Hello world'
+  tag 'snippet' do |tag|
+    snippet_name = tag.attr['name']
+    snippet = tag.globals.storage.snippet( tag.globals.page.lang, snippet_name )
+
+    if snippet
+      snippet.render( tag.globals.page.parser )
+    else
+      error "No snippet '#{snippet_name}' found"
+    end
   end
 
-  tag 'repeat' do |tag|
-    number = (tag.attr['times'] || '1').to_i
-    result = ''
-    number.times { result << tag.expand }
-    result
+  private
+
+  def find_part( tag )
+    tag.locals.page.find_part( tag.attr['part'] || 'body', tag.attr['inherit'] == 'true' )
   end
 
 end

data/lib/rayo/tags/navigation_tags.rb

@@ -8,7 +8,7 @@ module Rayo::Tags::NavigationTags
 
     if path.first.empty?
       path.shift
-      page = tag.locals.page.storage.root_page
+      page = tag.locals.page.storage.root_page( tag.globals.page.lang )
     else
       page = tag.locals.page
     end

data/lib/rayo/tags/property_tags.rb

@@ -6,20 +6,48 @@ module Rayo::Tags::PropertyTags
     tag.locals.page.context['title']
   end
 
+  tag 'description' do |tag|
+    tag.locals.page.context['description']
+  end
+
   tag 'path' do |tag|
-    curpath = tag.globals.page.path
+    basepath = tag.globals.page.path
     path = tag.locals.page.path
 
-    i = 0
-    while i < path.size && i < curpath.size && path[i] == curpath[i] do
-      i = i + 1
-    end
+    if basepath.empty?
+      [tag.locals.page.lang, *path].join('/')
+    else
+      basepath = basepath[0..-2]
+
+      i = 0
+      while i < path.size && i < basepath.size && path[i] == basepath[i] do
+        i = i + 1
+      end
 
-    '../' * (curpath.size - i) + path[i..-1].join('/')
+      '../' * (basepath.size - i) + path[i..-1].join('/')
+    end
   end
 
   tag 'link' do |tag|
-    "<a href=\"#{send 'tag:path', tag}\">#{tag.locals.page.context['title']}</a>"
+    "<a href=\"#{send 'tag:path', tag}\">#{tag.single? ? send( 'tag:title', tag ) : tag.expand}</a>"
+  end
+
+  tag 'if_url' do |tag|
+    if_url( tag ) && tag.expand || ''
+  end
+
+  tag 'unless_url' do |tag|
+    if_url( tag ) && '' || tag.expand
+  end
+
+  tag 'date' do |tag|
+    Time.now.strftime(tag.attr['format'] || '%A, %B %d, %Y')
+  end
+
+  private
+
+  def if_url( tag )
+    tag.locals.page.path =~ Regexp.new( tag.attr['matches'] )
   end
 
 end

data/lib/rayo/version.rb

@@ -1,7 +1,7 @@
 module Rayo
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rayo
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Alexey Noskov
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 +04:00
+date: 2010-11-02 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,17 +61,48 @@ dependencies:
         version: "1.0"
   type: :runtime
   version_requirements: *id003
-description: It's lightweight CMS based on Sinatra framework, where data are stored in file system (so you may use Git power) and enhanced Radius gem.
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Lightweight CMS based on Sinatra framework, where data are stored in file system (and so may be Git-powered) and enhanced using Radius gem.
 email: 
 - alexey.noskov@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
 files: 
 - lib/rayo.rb
+- lib/rayo/config/domain.rb
 - lib/rayo/storage.rb
 - lib/rayo/application.rb
 - lib/rayo/version.rb
@@ -85,13 +116,20 @@ files:
 - lib/rayo/tags/navigation_tags.rb
 - lib/rayo/config.rb
 - lib/rayo/tag_context.rb
+- MIT-LICENSE
+- README.rdoc
 has_rdoc: true
 homepage: http://github.com/alno/rayo
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Rayo CMS
+- --main
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement