rayo 0.1.0

data/lib/rayo.rb

@@ -0,0 +1,11 @@
+module Rayo
+
+  module Tags
+  end
+
+  module Models
+  end
+
+end
+
+require File.join(File.dirname(__FILE__), 'rayo', 'application.rb')

data/lib/rayo/application.rb

@@ -0,0 +1,54 @@
+require 'sinatra/base'
+
+require File.join(File.dirname(__FILE__), 'storage.rb')
+require File.join(File.dirname(__FILE__), 'config.rb')
+
+class Rayo::Application < Sinatra::Base
+
+  class << self
+
+    attr_accessor :config # Application configuration object
+
+    # Configure application
+    def configure
+      yield @config ||= Rayo::Config.new
+    end
+
+  end
+
+  def config
+    self.class.config
+  end
+
+  get '/' do
+    redirect_to_lang '' # Root page
+  end
+
+  get '*/' do |path|
+    redirect path # Remove trailing slashes
+  end
+
+  get '/*' do |path|
+    path = path.split '/' # Split path into segments
+
+    return redirect_to_lang path unless config.languages.include? path.first
+
+    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
+
+    [ page[:status], page.render ] # Return page status and content
+  end
+
+  private
+
+  def select_language
+    config.languages.first
+  end
+
+  def redirect_to_lang( path )
+    redirect [select_language, *path].join '/'
+  end
+
+end

data/lib/rayo/config.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), 'taggable.rb')
+require File.join(File.dirname(__FILE__), 'tags/property_tags.rb')
+require File.join(File.dirname(__FILE__), 'tags/content_tags.rb')
+require File.join(File.dirname(__FILE__), 'tags/navigation_tags.rb')
+
+class Rayo::Config
+
+  attr_accessor :content_dir
+  attr_accessor :languages
+  attr_accessor :page_exts
+
+  def initialize
+    @languages = ['en']
+    @page_exts = ['.yml']
+
+    @filters = {}
+
+    # Default filters
+    add_filter('html'){|source| source }
+
+    @tagger = Object.new
+    @tagger.extend Rayo::Taggable
+
+    # Default tags
+    add_tags Rayo::Tags::PropertyTags
+    add_tags Rayo::Tags::ContentTags
+    add_tags Rayo::Tags::NavigationTags
+  end
+
+  # Add tags defined in module
+  def add_tags( tag_module )
+    @tagger.extend tag_module
+  end
+
+  # Add filter
+  def add_filter( ext, &filter )
+    @filters[".#{ext}"] = filter
+  end
+
+  # Create new object containing all defined tags
+  def create_tagger
+    @tagger.clone
+  end
+
+  def directory( content_type )
+    File.join( @content_dir, content_type.to_s )
+  end
+
+  def renderable_exts
+    @filters.keys
+  end
+
+  def filter( ext )
+    @filters[ ext.to_s ]
+  end
+
+end

data/lib/rayo/models/page.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+require 'erubis'
+require 'radius'
+
+require File.join(File.dirname(__FILE__), '..', 'tag_context.rb')
+
+class Rayo::Models::Page
+
+  attr_reader :storage, :parent, :path
+
+  def initialize( storage, parent, path )
+    @storage = storage
+    @parent = parent
+    @path = path
+  end
+
+  def descendant( relative_path )
+    relative_path.inject( self ) {|page,slug| page.child( slug ) }
+  end
+
+  def children
+    @children ||= @storage.find_pages( directories ).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 = nil if page.file.nil? && page.directories.empty?
+
+    @children_cache[ slug ] = page
+  end
+
+  def directories
+    @directories ||= @storage.find_page_dirs( @parent.directories, @path.last )
+  end
+
+  def file
+    @file ||= @storage.find_page_file( @parent.directories, @path.last )
+  end
+
+  def parts
+    @parts ||= file ? @storage.find_page_parts( file ) : {}
+  end
+
+  def params
+    return @params if @params
+
+    segments = file[0..-(File.extname(file).length+1)].split(/[\/\\]/)[-@path.size..-1] || raise( "File doesn't correspond to path" )
+
+    @params = {}
+
+    segments.each_with_index do |segment,i|
+      @params[segment[1..-1]] = @path[i] if segment[0..0] == '%'
+    end
+
+    @params['path'] = path
+    @params
+  end
+
+  def context
+    return @context if @context
+
+    @context = @parent ? @parent.context.merge({ 'status' => 200 }) : { 'status' => 200 }
+    @context.merge! load_context( file ) if file
+    @context
+  end
+
+  def layout
+    @layout ||= @storage.layout( context['layout'] )
+  end
+
+  def []( key )
+    key = key.to_s
+
+    context[ key ] || params[ key ]
+  end
+
+  def render
+    layout.render( parser )
+  end
+
+  def parser
+    @parser ||= Radius::Parser.new( Rayo::TagContext.new( self ), :tag_prefix => 'r' )
+  end
+
+  private
+
+  def load_context( filename )
+    YAML::load( Erubis::Eruby.new( File.read( filename ) ).result( params ) )
+  end
+
+end

data/lib/rayo/models/renderable.rb

@@ -0,0 +1,19 @@
+class Rayo::Models::Renderable
+
+  attr_reader :file
+  attr_reader :filter
+
+  def initialize( file, filter )
+    @file = file
+    @filter = filter
+  end
+
+  def source
+    @source ||= File.read( file )
+  end
+
+  def render( parser )
+    filter.call( parser.parse( source ) )
+  end
+
+end

data/lib/rayo/models/root_page.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'page.rb')
+require File.join(File.dirname(__FILE__), 'status_page.rb')
+
+class Rayo::Models::RootPage < Rayo::Models::Page
+
+  def initialize( storage )
+    super( storage, nil, [] )
+  end
+
+  def directories
+    [ @storage.config.directory :pages ]
+  end
+
+  def file
+    @file ||= @storage.find_page_file( directories, 'index' )
+  end
+
+  def params
+    @params ||= { 'path' => path }
+  end
+
+end

data/lib/rayo/models/status_page.rb

@@ -0,0 +1,31 @@
+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 )
+
+    @status = status
+  end
+
+  def directories
+    []
+  end
+
+  def file
+    @file ||= @storage.find_page_file( @parent.directories, @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
+  end
+
+  def params
+    { 'path' => path }
+  end
+
+end

data/lib/rayo/storage.rb

@@ -0,0 +1,127 @@
+require File.join(File.dirname(__FILE__), 'models', 'root_page.rb')
+require File.join(File.dirname(__FILE__), 'models', 'renderable.rb')
+
+class Rayo::Storage
+
+  attr_reader :config
+
+  def initialize( config, lang )
+    @config = config
+
+    @lang = lang
+    @lang_prefix = '.' + lang
+
+    @layouts = {}
+    @snippets = {}
+  end
+
+  def snippet( name )
+    @snipetts[name.to_s] ||= find_renderable_file( :snippets, 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" )
+  end
+
+  def root_page
+    @root_page ||= Rayo::Models::RootPage.new( self )
+  end
+
+  def page( path )
+    root_page.descendant( path )
+  end
+
+  def status_page( path, status )
+    Rayo::Models::StatusPage.new( self, root_page, path, status )
+  end
+
+  def find_renderable( type, name )
+    if file = find_file( [config.directory( type )], name, config.renderable_exts )
+      renderable( file, File.extname( file ) )
+    end
+  end
+
+  def find_page_file( dirs, slug )
+    find_file( dirs, slug, config.page_exts )
+  end
+
+  def find_page_dirs( dirs, slug )
+    find_files dirs, slug, ['']
+  end
+
+  def find_pages( dirs )
+    find_files dirs, '*', config.page_exts + ['']
+  end
+
+  def find_page_parts( page_file )
+    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|
+      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
+        else
+          parts[ elems[0] ] ||= renderable( file, ext ) if elems[1] == @lang
+        end
+      end
+    end
+    parts
+  end
+
+  private
+
+  def renderable( file, ext )
+    Rayo::Models::Renderable.new( 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 }
+    nil
+  end
+
+  # Find files with given name (or variable) and extension from given set
+  def find_files( dirs, name, exts )
+    results = []
+    glob_files( dirs, 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
+    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, '%*',  /^%.+$/, exts, &block # Search with variable without language
+  end
+
+  def glob( dirs, mask_wo_ext, base_regexp, exts )
+    mask = mask_wo_ext + ext_mask( exts )
+
+    dirs.each do |dir|
+      Dir.glob File.join( dir, mask ) do |file|
+        ext = File.extname( file )
+        base = File.basename( file, ext )
+
+        yield file, base, ext if exts.include?( ext ) && base =~ base_regexp
+      end
+    end
+  end
+
+  def ext_mask( exts )
+    if exts.size == 1 # Only one extension
+      exts.first # Use it in mask
+    elsif !exts.include? '' # No empty extension
+      '.*' # Use any extension mask
+    elsif mask_wo_ext[-1..-1] == '*' # Mask ends with star
+      '' # No need for another star
+    else
+      '*' # Any prefix
+    end
+  end
+
+end

data/lib/rayo/tag_context.rb

@@ -0,0 +1,18 @@
+class Rayo::TagContext < Radius::Context
+
+  attr_reader :page
+
+  def initialize(page)
+    super()
+
+    @page = page
+
+    globals.page = @page
+
+    tagger = @page.storage.config.create_tagger
+    tagger.methods.each do |name|
+      define_tag(name[4..-1]) { |tag_binding| tagger.send name, tag_binding } if name[0..3] == 'tag:'
+    end
+  end
+
+end

data/lib/rayo/taggable.rb

@@ -0,0 +1,19 @@
+module Rayo::Taggable
+
+  module ClassMethods
+
+    def tag( name, &block )
+      define_method("tag:#{name}", &block)
+    end
+
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def error( text )
+    "<strong class=\"error\">#{text}</strong>"
+  end
+
+end

data/lib/rayo/tags/content_tags.rb

@@ -0,0 +1,46 @@
+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
+      part.render( tag.globals.page.parser )
+    else
+      error "No part '#{part_name}' found for page '#{tag.locals.page.path}'"
+    end
+  end
+
+  tag 'content_for_layout' do |tag|
+    send 'tag:content', tag
+  end
+
+  tag 'snippet' do |tag|
+    number = (tag.attr['times'] || '1').to_i
+    result = ''
+    number.times { result << tag.expand }
+    result
+  end
+
+  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

data/lib/rayo/tags/navigation_tags.rb

@@ -0,0 +1,63 @@
+module Rayo::Tags::NavigationTags
+
+  include Rayo::Taggable
+
+  tag 'find' do |tag|
+    url = tag.attr['url']
+    path = url.split('/')
+
+    if path.first.empty?
+      path.shift
+      page = tag.locals.page.storage.root_page
+    else
+      page = tag.locals.page
+    end
+
+    page = page.descendant( path )
+
+    if page
+      tag.locals.page = page
+      tag.expand
+    else
+      error "No page '#{url}' found"
+    end
+  end
+
+  tag 'children' do |tag|
+    tag.locals.children = tag.locals.page.children
+    tag.expand
+  end
+
+  tag 'children:count' do |tag|
+    tag.locals.children.size
+  end
+
+  tag 'children:first' do |tag|
+    if first = tag.locals.children.first
+      tag.locals.page = first
+      tag.expand
+    end
+  end
+
+  tag 'children:last' do |tag|
+    if first = tag.locals.children.last
+      tag.locals.page = first
+      tag.expand
+    end
+  end
+
+  tag 'children:each' do |tag|
+    result = ''
+
+    children = tag.locals.children
+    children.each_with_index do |item, i|
+      tag.locals.child = item
+      tag.locals.page = item
+      tag.locals.first_child = i == 0
+      tag.locals.last_child = i == children.length - 1
+      result << tag.expand
+    end
+    result
+  end
+
+end

data/lib/rayo/tags/property_tags.rb

@@ -0,0 +1,25 @@
+module Rayo::Tags::PropertyTags
+
+  include Rayo::Taggable
+
+  tag 'title' do |tag|
+    tag.locals.page.context['title']
+  end
+
+  tag 'path' do |tag|
+    curpath = 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
+
+    '../' * (curpath.size - i) + path[i..-1].join('/')
+  end
+
+  tag 'link' do |tag|
+    "<a href=\"#{send 'tag:path', tag}\">#{tag.locals.page.context['title']}</a>"
+  end
+
+end

data/lib/rayo/version.rb

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

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: rayo
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alexey Noskov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-18 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: erubis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: radius
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        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.
+email: 
+- alexey.noskov@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rayo.rb
+- lib/rayo/storage.rb
+- lib/rayo/application.rb
+- lib/rayo/version.rb
+- lib/rayo/taggable.rb
+- lib/rayo/models/root_page.rb
+- lib/rayo/models/page.rb
+- lib/rayo/models/status_page.rb
+- lib/rayo/models/renderable.rb
+- lib/rayo/tags/property_tags.rb
+- lib/rayo/tags/content_tags.rb
+- lib/rayo/tags/navigation_tags.rb
+- lib/rayo/config.rb
+- lib/rayo/tag_context.rb
+has_rdoc: true
+homepage: http://github.com/alno/rayo
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Lightweight CMS based on Sinatra and Radius
+test_files: []
+