alfa 0.0.1.pre → 0.0.2.pre

data/lib/alfa/web_application.rb

@@ -1,121 +1,142 @@
 # coding: utf-8
+require 'alfa/support'
 require 'alfa/exceptions'
+require 'alfa/application'
+require 'alfa/tfile'
+require 'alfa/controller'
+require 'alfa/router'
 require 'ruty'
+require 'ruty/bugfix'
+require 'ruty/upgrade'
 require 'ruty/tags/resources'
 
 Encoding.default_external='utf-8'
 Encoding.default_internal='utf-8'
 
 module Alfa
-  class WebApplication
+  class WebApplication < Alfa::Application
 
-    # main rack routine
-    def self.call env
-      @env = env
-      begin
-        response_code = 200
-        route, params = self.find_route
-        c_sym = route[:options].has_key?(:controller) ? route[:options][:controller] : params[:controller]
-        a_sym = route[:options].has_key?(:action) ? route[:options][:action] : params[:action]
-        l_sym = route[:options].has_key?(:layout) ? route[:options][:layout] : :default
-        controller = self.invoke_controller(c_sym)
-        raise Alfa::RouteException404 unless controller.public_methods.include?(a_sym)
-        controller.__send__(a_sym)
-        data = controller._instance_variables_hash
-        Ruty::Tags::RequireStyle.clean_cache
-        content = self.render_template(File.join(c_sym.to_s, a_sym.to_s + '.tpl'), data)
-        body = self.render_layout(l_sym.to_s + '.tpl', {body: content})
-      rescue Alfa::RouteException404
-        response_code = 404
-        body = 'Url not found'
-      rescue Exception => e
-        response_code = 500
-        body = 'Error occured: ' + e.message + ' at ' + e.backtrace.first
-      end
-      headers = {
-          "Content-Type" => 'text/html; charset=utf-8',
-      }
-      [response_code, headers, [body]]
-    end
-
-    # set routes
-    def self.routes &block
-      @routes = []
-      class_eval &block
-    end
-
-
-    def self.route rule, options = {}
-      @routes << {:rule => rule, :options => options}
-    end
-
-  private
+    @namespaces_stack = []
+    @bputs = []
 
-    def self.find_route
-      url = @env['PATH_INFO']
-      @routes.each do |route|
-        is_success, params = self.route_match? route[:rule], url
-        return route, params if is_success
+    def self.inherited subclass
+      instance_variables.each do |var|
+        subclass.instance_variable_set(var, instance_variable_get(var))
       end
-      raise Alfa::RouteException404
     end
 
+    def self.init!
+      Alfa::Router.set_apps_dir File.join(PROJECT_ROOT, 'apps')
+      require File.join(PROJECT_ROOT, 'config/routes')
+      super
+    end
 
-    def self.route_match? rule, url
-      if rule.is_a? String
-        rule_trail_slash = rule[-1] == '/'
-        url_trail_slash = url[-1] == '/'
-        rule_segments = rule.split('/').reject(&:empty?)
-        url_segments = url.split('/').reject(&:empty?)
-        rule_segments += [nil]*(url_segments.size - rule_segments.size) if url_segments.size > rule_segments.size
-        pares = {}
-        skip_flag = false
-        fail_flag = false
-        rule_segments.zip(url_segments).each do |rule_segment, url_segment|
-          skip_flag = true if rule_segment == '**'
-          if rule_segment =~ /^:[a-z]+\w*$/i && url_segment =~ /^[a-z0-9_]+$/
-            pares[rule_segment[1..-1].to_sym] = url_segment
-          elsif (rule_segment == url_segment) || (rule_segment == '*' && url_segment =~ /^[a-z0-9_]+$/) || (rule_segment == nil && skip_flag) || rule_segment == '**'
+    # main rack routine
+    def self.call env
+      start_time = Time.now
+      response_code = nil # required for store context inside @logger.portion
+      headers = {} # required for store context inside @logger.portion
+      body = nil # required for store context inside @logger.portion
+      @logger.portion do |l|
+        @config[:db].each_value { |db| db.loggers = [l] }
+        @env = env
+        @bputs = []
+        headers = {"Content-Type" => 'text/html; charset=utf-8'}
+        t_sym = :default
+        begin
+          l.info "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']} #{env['SERVER_PROTOCOL']} from #{env['REMOTE_ADDR']} at #{DateTime.now}"
+          #l.info "  HTTP_HOST: #{env['HTTP_HOST']}"
+          #@logger.info "  HTTP_ACCEPT: #{env['HTTP_ACCEPT']}"
+          #@logger.info "  HTTP_ACCEPT_LANGUAGE: #{env['HTTP_ACCEPT_LANGUAGE']}"
+          #@logger.info "  PATH_INFO: #{env['PATH_INFO']}"
+          response_code = 200
+          route, params = self.routes.find_route @env['PATH_INFO']
+          t_sym = route[:options].has_key?(:type) ? route[:options][:type] : :default
+          if t_sym == :asset
+            body = File.read(File.expand_path('../../../assets/' + params[:path], __FILE__))
+            case File.extname(params[:path]).downcase
+              when '.js'
+                headers = {'Content-Type' => 'application/javascript; charset=utf-8'}
+              when '.css'
+                headers = {'Content-Type' => 'text/css; charset=utf-8'}
+              else
+            end
           else
-            fail_flag = true
-            break
+            app_sym = route[:options].has_key?(:app) ? route[:options][:app] : params[:app]
+            c_sym = route[:options].has_key?(:controller) ? route[:options][:controller] : params[:controller]
+            a_sym = route[:options].has_key?(:action) ? route[:options][:action] : params[:action]
+            l_sym = route[:options].has_key?(:layout) ? route[:options][:layout] : :default
+            controller = self.invoke_controller(app_sym, c_sym)
+            raise Alfa::RouteException404 unless controller.public_methods.include?(a_sym)
+            controller.__send__(a_sym)
+            data = controller._instance_variables_hash
+            Ruty::Tags::RequireStyle.clean_cache
+            content = self.render_template(app_sym.to_s, File.join(c_sym.to_s, a_sym.to_s + '.tpl'), data)
+            body = self.render_layout(app_sym.to_s, l_sym.to_s + '.tpl', {body: content})
+            headers = {"Content-Type" => 'text/html; charset=utf-8'}
           end
+        rescue Alfa::RouteException404 => e
+          response_code = 404
+          body = 'Url not found<br>urls map:<br>'
+          body += self.routes.instance_variable_get(:@routes).inspect
+          l.info "404: Url not found (#{e.message})"
+        rescue Exception => e
+          response_code = 500
+          body = "Error occured: #{e.message} at #{e.backtrace.first}<br>Full backtrace:<br>#{e.backtrace.join("<br>")}"
         end
-        fail_flag = true if rule_trail_slash != url_trail_slash
-        return !fail_flag, pares
-      elsif rule.is_a? Regexp
-        match = rule.match url
-        if match
-          pares = Hash[match.names.map(&:to_sym).zip(match.captures)]
-          return true, pares
-        else
-          return false, {}
+        if t_sym == :default
+          #debug_info = '<hr>Queries:<br>' + @logger.logs.map { |log|
+          #  r = "#{log[:num]}: #{log[:query]} | #{log[:status]}"
+          #  r += ", error: #{log[:error]}" if log[:status] == :fail
+          #  r += ", logger hash: #{log[:logger_hash]}"
+          #  r
+          #}.join('<br>')
+          debug_info = "<hr>rack env: #{env.inspect}"
         end
+        l.info "RESPONSE: #{response_code} (#{sprintf('%.4f', Time.now - start_time)} sec)"
+        l << "\n"
       end
+      @log_file.flush
+      #@logger = nil
+      return [response_code, headers, [body, @bputs.join('<br>')]]
+    end
+
+    # router
+    def self.routes
+      @router ||= Alfa::Router
     end
 
 
-    def self.invoke_controller controller
+    def self.bputs arg
+      @bputs << "#{arg}\n"
+    end
+
+
+  # private section
+
+    def self.invoke_controller application, controller
       @controllers ||= {}
-      controller = controller.to_s
-      require File.join(PROJECT_ROOT, 'app/controllers', controller.to_s)
-      @controllers[controller] ||= Kernel.const_get(Alfa::Support.capitalize_name(controller)+'Controller').new
-      @controllers[controller]
+      require File.join(PROJECT_ROOT, 'apps', application.to_s, 'controllers', controller.to_s)
+      @controllers[[application, controller]] ||= Kernel.const_get(Alfa::Support.capitalize_name(controller)+'Controller').new
     end
 
-    def self.render_template template, data = {}
-      t = self.loader.get_template File.join('views', template)
+    def self.render_template app, template, data = {}
+      t = self.loader.get_template File.join(app, 'templates', template)
       t.render data
     end
 
-    def self.render_layout layout, data = {}
-      t = self.loader.get_template File.join('layouts', layout)
+    def self.render_layout app, layout, data = {}
+      t = self.loader.get_template File.join(app, 'layouts', layout)
       t.render data
     end
 
     def self.loader
-      @loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(PROJECT_ROOT, 'app'))
+      @loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(PROJECT_ROOT, 'apps'))
     end
 
   end
-end
+end
+
+def bputs arg
+  Alfa::WebApplication.bputs arg
+end

data/lib/alfa.rb

@@ -5,4 +5,4 @@ require 'alfa/web_application'
 require 'alfa/cli_application'
 require 'alfa/controller'
 require 'alfa/database'
-require 'alfa/models'
+require 'alfa/models'

data/lib/ruty/bugfix.rb

@@ -0,0 +1,21 @@
+module Ruty
+  class Parser
+    # tokenize the sourcecode and return an array of tokens
+    def tokenize
+      result = Datastructure::TokenStream.new
+      @source.scan(TAG_REGEX).each do |match|
+        result << [:text, match[0]] if match[0] and not match[0].empty?
+        if data = match[1]
+          result << [:block, data.strip]
+        elsif data = match[2]
+          result << [:var, data.strip]
+        elsif data = match[3]
+          result << [:comment, data.strip]
+        end
+      end
+      rest = $~ ? @source[$~.end(0)..-1] : @source
+      result << [:text, rest] if not rest.empty?
+      result.close
+    end
+  end
+end

data/lib/ruty/tags/resources.rb

@@ -5,13 +5,15 @@ class Ruty::Tags::RequireStyle < Ruty::Tag
   def initialize parser, argstring
     @@styles << argstring unless @@styles.include? argstring
   end
+  def self.add path
+    @@styles << path unless @@styles.include? path
+  end
   def self.clean_cache
     @@styles = []
   end
   Ruty::Tags.register(self, :require_style)
 end
 
-
 class Ruty::Tags::Styles < Ruty::Tag
   def initialize parser, argstring
   end
@@ -23,11 +25,46 @@ class Ruty::Tags::Styles < Ruty::Tag
   Ruty::Tags.register(self, :styles)
 end
 
+class Ruty::Tags::Require960gs < Ruty::Tag
+  @@styles = []
+  def initialize parser, argstring
+    Ruty::Tags::RequireStyle.add '/~assets/css/960gs/960.css'
+  end
+  Ruty::Tags.register(self, :require_960gs)
+end
+
+class Ruty::Tags::Require960gs24 < Ruty::Tag
+  @@styles = []
+  def initialize parser, argstring
+    case argstring
+      when 'text'
+        Ruty::Tags::RequireStyle.add '/~assets/css/960gs/text.css'
+      when 'reset'
+        Ruty::Tags::RequireStyle.add '/~assets/css/960gs/reset.css'
+      when 'full'
+        Ruty::Tags::RequireStyle.add '/~assets/css/960gs/reset.css'
+        Ruty::Tags::RequireStyle.add '/~assets/css/960gs/text.css'
+      else
+    end
+    Ruty::Tags::RequireStyle.add '/~assets/css/960gs/960_24_col.css'
+  end
+  Ruty::Tags.register(self, :require_960gs24)
+end
+
+
 # SCRIPTS
 
 # Require external script that must be included at bottom of page.
 class Ruty::Tags::RequireScript < Ruty::Tag
+  @@scripts = []
   def initialize parser, argstring
+    Ruty::Tags::RequireScript.add argstring
+  end
+  def self.add path
+    @@scripts << path unless @@scripts.include? path
+  end
+  def self.clean_cache
+    @@scripts = []
   end
   Ruty::Tags.register(self, :require_script)
 end
@@ -43,6 +80,11 @@ end
 class Ruty::Tags::Scripts < Ruty::Tag
   def initialize parser, argstring
   end
+  def render_node context, stream
+    Ruty::Tags::RequireScript.class_variable_get(:@@scripts).each do |file|
+      stream << "<script src=\"#{file}\"></script>\n"
+    end
+  end
   Ruty::Tags.register(self, :scripts)
 end
 
@@ -63,6 +105,7 @@ end
 # Shortcut for jquery (required bottom)
 class Ruty::Tags::RequireJquery < Ruty::Tag
   def initialize parser, argstring
+    Ruty::Tags::RequireScript.add '/~assets/js/jquery/jquery-latest.js'
   end
   Ruty::Tags.register(self, :require_jquery)
 end
@@ -72,4 +115,4 @@ class Ruty::Tags::RequireJqueryPlugin < Ruty::Tag
   def initialize parser, argstring
   end
   Ruty::Tags.register(self, :require_jquery_plugin)
-end
+end

data/lib/ruty/upgrade.rb

@@ -0,0 +1,61 @@
+# escape variables by default
+# {{ variable }} transforms to {{ variable|escape }}
+# {{ variable|raw }} transforms to {{ variable }}
+module Ruty
+  class ParserController
+
+    # parse everything until the block returns true
+    def parse_until &block
+      result = Datastructure::NodeStream.new(self)
+      while not @tokenstream.eos?
+        token, value = @tokenstream.next
+
+        # text tokens are returned just if the arn't empty
+        if token == :text
+          @first = false if @first and not value.strip.empty?
+          result << Datastructure::TextNode.new(value) \
+                    if not value.empty?
+
+          # variables leave the parser just if they have just
+          # one name and some optional filters on it.
+        elsif token == :var
+          @first = false
+          names = []
+          filters = []
+          Parser::parse_arguments(value).each do |arg|
+            if arg.is_a?(Array)
+              filters << arg
+            else
+              names << arg
+            end
+          end
+
+          filters << [:escape] if (filters & [[:raw], [:escape]]).empty?
+          filters -= [[:raw]]
+
+          fail('Invalid syntax for variable node') if names.size != 1
+          result << Datastructure::VariableNode.new(names[0], filters)
+
+          # blocks are a bit more complicated. first they can act as
+          # needle tokens for other blocks, on the other hand blocks
+          # can have their own subprogram
+        elsif token == :block
+          p = value.split(/\s+/, 2)
+          name = p[0].to_sym
+          args = p[1] || ''
+          if block.call(name, args)
+            @first = false
+            return result.to_nodelist
+          end
+
+          tag = Tags[name]
+          fail("Unknown tag #{name.inspect}") if tag.nil?
+          result << tag.new(self, args)
+          @first = false
+        end
+      end
+      result.to_nodelist
+      end
+
+  end
+end

data/test/data/test_router/config/routes.rb

@@ -0,0 +1,4 @@
+Alfa::Router.draw do
+  mount '/admin/', :backend
+  mount '/', :frontend
+end

data/test/test_alfa.rb

@@ -1,57 +1,6 @@
 require 'test/unit'
 require 'alfa'
 
-class DB1 < Alfa::Database::MySQL; end
-class DB2 < Alfa::Database::MySQL; end
-
 class AlfaTest < Test::Unit::TestCase
-  def test_route_match
-    # string rules, positive cases
-    assert_equal([true, {}], Alfa::WebApplication.route_match?('/', '/'))
-    assert_equal([true, {action: 'foo'}], Alfa::WebApplication.route_match?('/:action', '/foo'))
-    assert_equal([true, {action: 'foo'}], Alfa::WebApplication.route_match?('/:action/', '/foo/'))
-    assert_equal([true, {controller: 'foo', action: 'bar'}], Alfa::WebApplication.route_match?('/:controller/:action', '/foo/bar'))
-    assert_equal([true, {}], Alfa::WebApplication.route_match?('/foo/bar', '/foo/bar'))
-    assert_equal([true, {}], Alfa::WebApplication.route_match?('/*/bar', '/foo/bar'))
-    assert_equal([true, {action: 'bar'}], Alfa::WebApplication.route_match?('/*/:action', '/foo/bar'))
-    assert_equal([true, {}], Alfa::WebApplication.route_match?('/**', '/foo/bar'))
-    assert_equal([true, {controller: 'foo'}], Alfa::WebApplication.route_match?('/:controller/**', '/foo/bar/baz'))
-
-    # string rules, negative cases
-    assert_equal([false, {action: 'foo'}], Alfa::WebApplication.route_match?('/:action', '/foo/'))
-    assert_equal([false, {action: 'foo'}], Alfa::WebApplication.route_match?('/:action/', '/foo'))
-    assert_equal([false, {}], Alfa::WebApplication.route_match?('/foo/bar/', '/foo/bar'))
-    assert_equal([false, {}], Alfa::WebApplication.route_match?('/*', '/foo/bar'))
-    assert_equal([false, {}], Alfa::WebApplication.route_match?('/*/', '/foo/bar'))
-    assert_equal([false, {}], Alfa::WebApplication.route_match?('/*', '/foo/bar/'))
-    assert_equal([false, {}], Alfa::WebApplication.route_match?('/**/', '/foo/bar'))
-    assert_equal([false, {}], Alfa::WebApplication.route_match?('/**', '/foo/bar/'))
-
-    # regexp rules, positive cases
-    rule = Regexp.new('^/(?<controller>[^/]+)/(?<action>[^/]+)?$')
-    assert_equal([true, {controller: 'default', action: 'index'}], Alfa::WebApplication.route_match?(rule, '/default/index'))
-
-    # regexp rules, negative cases
-    rule = Regexp.new('^/(?<controller>[^/]+)/(?<action>[^/]+)?$')
-    assert_equal([false, {}], Alfa::WebApplication.route_match?(rule, '/'))
-  end
-
-
-  def test_capitalize_name
-    assert_equal('Foo', Alfa::Support.capitalize_name(:foo))
-    assert_equal('Foo', Alfa::Support.capitalize_name('foo'))
-    assert_equal('Foo', Alfa::Support.capitalize_name('FOO'))
-    assert_equal('Foo', Alfa::Support.capitalize_name('Foo'))
-    assert_equal('FooBar', Alfa::Support.capitalize_name(:foo_bar))
-    assert_equal('FooBar', Alfa::Support.capitalize_name('foo_bar'))
-    assert_equal('FooBar', Alfa::Support.capitalize_name(:foo__bar))
-    assert_equal('BarBaz', Alfa::Support.capitalize_name('foo/bar_baz'))
-  end
 
-  def test_inheritance
-    DB1.host = 'localhost'
-    DB2.host = 'otherhost'
-    assert_equal('localhost', DB1.host)
-    assert_equal('otherhost', DB2.host)
-  end
-end
+end

data/test/test_router.rb

@@ -0,0 +1,132 @@
+require 'test/unit'
+require 'alfa/router'
+
+class AlfaRouterTest < Test::Unit::TestCase
+  def test_01 # route_match
+    # string rules, positive cases
+    assert_equal([true, {}], Alfa::Router.route_match?('/', '/'))
+    assert_equal([true, {action: 'foo'}], Alfa::Router.route_match?('/:action', '/foo'))
+    assert_equal([true, {action: 'foo'}], Alfa::Router.route_match?('/:action/', '/foo/'))
+    assert_equal([true, {controller: 'foo', action: 'bar'}], Alfa::Router.route_match?('/:controller/:action', '/foo/bar'))
+    assert_equal([true, {}], Alfa::Router.route_match?('/foo/bar', '/foo/bar'))
+    assert_equal([true, {}], Alfa::Router.route_match?('/*/bar', '/foo/bar'))
+    assert_equal([true, {action: 'bar'}], Alfa::Router.route_match?('/*/:action', '/foo/bar'))
+    assert_equal([true, {}], Alfa::Router.route_match?('/**', '/foo/bar'))
+    assert_equal([true, {controller: 'foo'}], Alfa::Router.route_match?('/:controller/**', '/foo/bar/baz'))
+    assert_equal([true, {path: 'js/jquery/jquery-latest.js', type: :asset}], Alfa::Router.route_match?('/~assets/:path**', '/~assets/js/jquery/jquery-latest.js'))
+    assert_equal([true, {}], Alfa::Router.route_match?('/hello.html', '/hello.html'))
+
+    # string rules, negative cases
+    assert_equal([false, {action: 'foo'}], Alfa::Router.route_match?('/:action', '/foo/'))
+    assert_equal([false, {action: 'foo'}], Alfa::Router.route_match?('/:action/', '/foo'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/foo/bar/', '/foo/bar'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/*', '/foo/bar'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/*/', '/foo/bar'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/*', '/foo/bar/'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/**/', '/foo/bar'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/**', '/foo/bar/'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/~assets/:path**', '/~assets/js/jquery/non-exists-file.js'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/~assets/:path**', '/~assets/js/jquery/'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/~assets/:path**', '/~assets/js/jquery'))
+    assert_equal([false, {}], Alfa::Router.route_match?('/hello.html', '/~assets/js/jquery/jquery-latest.js'))
+
+    # regexp rules, positive cases
+    rule = Regexp.new('^/(?<controller>[^/]+)/(?<action>[^/]+)?$')
+    assert_equal([true, {controller: 'default', action: 'index'}], Alfa::Router.route_match?(rule, '/default/index'))
+
+    # regexp rules, negative cases
+    rule = Regexp.new('^/(?<controller>[^/]+)/(?<action>[^/]+)?$')
+    assert_equal([false, {}], Alfa::Router.route_match?(rule, '/'))
+  end
+
+
+  def test_02 # app_match
+    # positive cases
+    assert_equal(true, Alfa::Router.app_match?('/foo/', '/foo/'))
+    assert_equal(true, Alfa::Router.app_match?('/foo', '/foo/'))
+    assert_equal(true, Alfa::Router.app_match?('/foo/', '/foo/bar'))
+    assert_equal(true, Alfa::Router.app_match?('/foo/bar/', '/foo/bar/'))
+
+    # negative cases
+    assert_equal(false, Alfa::Router.app_match?('/foo/', '/bar/'))
+    assert_equal(false, Alfa::Router.app_match?('/foo', '/bar/'))
+    assert_equal(false, Alfa::Router.app_match?('/foo/', '/bar/bar'))
+    assert_equal(false, Alfa::Router.app_match?('/foo/bar/', '/bar/bar'))
+  end
+
+
+  def prepare_router
+    Alfa::Router.draw do
+      route '/hello.html'
+      mount '/admin/', :admin
+      Alfa::Router.context :app => :admin do
+        Alfa::Router.draw do
+          route '/', :controller => :main, :action => :index, :layout => :admin
+          route '/:controller', :action => :index
+        end
+      end
+      mount '/', :frontend
+      Alfa::Router.context :app => :frontend do
+        Alfa::Router.draw do
+          route '/', :controller => :main, :action => :index, :layout => :index
+          route '/:action', :controller => :main, :layout => :internal
+          route '/:controller/:action', :layout => :internal
+          route '/:controller/:action/:id', :layout => :internal
+        end
+      end
+    end
+  end
+
+  # Checks right order of draw and mounted rules
+  def test_03 # Router's internal routes struct
+    prepare_router
+    assert_equal(
+        [
+            {:rule=>"/~assets/:path**", :options=>{:type=>:asset}},
+            {:rule=>"/hello.html", :options=>{}},
+            {:context=>{:app=>{:path=>"/admin/", :app=>:admin, :options=>{}}},
+             :routes=>[
+                 {:rule=>"/", :options=>{:controller=>:main, :action=>:index, :layout=>:admin}},
+                 {:rule=>"/:controller", :options=>{:action=>:index}}
+             ]},
+            {:context=>{:app=>{:path=>"/", :app=>:frontend, :options=>{}}},
+             :routes=>[
+                 {:rule=>"/", :options=>{:controller=>:main, :action=>:index, :layout=>:index}},
+                 {:rule=>"/:action", :options=>{:controller=>:main, :layout=>:internal}},
+                 {:rule=>"/:controller/:action", :options=>{:layout=>:internal}},
+                 {:rule=>"/:controller/:action/:id", :options=>{:layout=>:internal}},
+             ]},
+        ],
+        Alfa::Router.instance_variable_get(:@routes)
+    )
+  end
+
+
+  def test_04 # mount
+    prepare_router
+    #puts Alfa::Router.instance_variable_get(:@routes)
+    assert_equal([{rule: '/hello.html', options: {}}, {}], Alfa::Router.find_route('/hello.html'))
+    assert_equal([{rule: '/', options: {app: :frontend, controller: :main, action: :index, layout: :index}}, {}], Alfa::Router.find_route('/'))
+    assert_equal([{rule: '/:action', options: {app: :frontend, controller: :main, layout: :internal}}, {action: 'foo'}], Alfa::Router.find_route('/foo'))
+    assert_equal([{rule: '/:controller/:action', options: {app: :frontend, layout: :internal}}, {controller: 'foo', action: 'bar'}], Alfa::Router.find_route('/foo/bar'))
+    assert_equal([{rule: '/:controller/:action/:id', options: {app: :frontend, layout: :internal}}, {controller: 'foo', action: 'bar', id: '8'}], Alfa::Router.find_route('/foo/bar/8'))
+    assert_equal([{rule: '/', options: {app: :admin, controller: :main, action: :index, layout: :admin}}, {}], Alfa::Router.find_route('/admin/'))
+    assert_equal([{rule: '/:controller', options: {app: :admin, action: :index}}, {controller: 'foo'}], Alfa::Router.find_route('/admin/foo'))
+    assert_raise Alfa::RouteException404 do
+      Alfa::Router.find_route('/admin/foo/bar')
+    end
+    assert_equal([{rule: '/~assets/:path**', options: {type: :asset}}, {path: 'js/jquery/jquery-latest.js', type: :asset}], Alfa::Router.find_route('/~assets/js/jquery/jquery-latest.js'))
+    #assert_equal([{rule: '/:controller/:action/:id', options: {app: :backend, layout: :internal}}, {controller: 'foo', action: 'bar', id: '8'}], Alfa::Router.find_route('/foo/bar/8'))
+  end
+
+  # this test loads routes.rb files from data/test_router directory to simulate real project skeletron
+  def test_05 # load_from_files
+    assert_equal([{rule: '/', options: {app: :frontend, controller: :main, action: :index, layout: :index}}, {}], Alfa::Router.find_route('/'))
+    assert_equal([{rule: '/:action', options: {app: :frontend, controller: :main, layout: :internal}}, {action: 'foo'}], Alfa::Router.find_route('/foo'))
+    assert_equal([{rule: '/:controller/:action', options: {app: :frontend, layout: :internal}}, {controller: 'foo', action: 'bar'}], Alfa::Router.find_route('/foo/bar'))
+    assert_equal([{rule: '/:controller/:action/:id', options: {app: :frontend, layout: :internal}}, {controller: 'foo', action: 'bar', id: '8'}], Alfa::Router.find_route('/foo/bar/8'))
+    assert_equal([{rule: '/', options: {app: :admin, controller: :main, action: :index, layout: :admin}}, {}], Alfa::Router.find_route('/admin/'))
+    assert_equal([{rule: '/:controller', options: {app: :admin, action: :index}}, {controller: 'foo'}], Alfa::Router.find_route('/admin/foo'))
+  end
+
+end

data/test/test_support.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'alfa/support'
+require 'alfa/database/mysql'
+
+class DB1 < Alfa::Database::MySQL; end
+class DB2 < Alfa::Database::MySQL; end
+
+class AlfaSupportTest < Test::Unit::TestCase
+  def test_capitalize_name
+    assert_equal('Foo', Alfa::Support.capitalize_name(:foo))
+    assert_equal('Foo', Alfa::Support.capitalize_name('foo'))
+    assert_equal('Foo', Alfa::Support.capitalize_name('FOO'))
+    assert_equal('Foo', Alfa::Support.capitalize_name('Foo'))
+    assert_equal('FooBar', Alfa::Support.capitalize_name(:foo_bar))
+    assert_equal('FooBar', Alfa::Support.capitalize_name('foo_bar'))
+    assert_equal('FooBar', Alfa::Support.capitalize_name(:foo__bar))
+    assert_equal('BarBaz', Alfa::Support.capitalize_name('foo/bar_baz'))
+  end
+
+  def test_inheritance
+    DB1.host = 'localhost'
+    DB2.host = 'otherhost'
+    assert_equal('localhost', DB1.host)
+    assert_equal('otherhost', DB2.host)
+  end
+end