alfa 0.0.2.pre → 0.0.4.pre

data/lib/alfa/application.rb

@@ -1,36 +1,56 @@
 require 'alfa/logger'
 require 'alfa/config'
+require 'alfa/exceptions'
+
+Encoding.default_external = 'utf-8'
+Encoding.default_internal = 'utf-8'
 
 module Alfa
+
+  # Dirty hack. Using constant-hash to store values. Ruby forbid dynamically change constants, but it allow change items of constant-structs
+  # 1st using - in rake tasks (see self.load_tasks)
+  VARS = {}
+
   class Application
     private_class_method :new
 
-    include Alfa::ClassInheritance
+    include ClassInheritance
     inheritable_attributes :config
 
     @config = Alfa::Config.new
 
-    def self.config args=nil
-      return @config if args.nil?
-      @config.merge args
+    def self.config(kwargs={})
+      @config.merge! kwargs
     end
 
+
     def self.init!
-      @log_file = File.open(File.join(@config[:log][:file]), File::WRONLY | File::APPEND | File::CREAT)
-      @logger = Alfa::Logger.new(@log_file)
-      str = "Application (pid=#{$$}) started at #{DateTime.now}"
-      @logger.info "#{'='*str.length}\n#{str}"
-      @logger.info "  PROJECT_ROOT: #{@config[:project_root]}"
-      @logger.info "  DOCUMENT_ROOT: #{@config[:document_root]}\n"
-      @log_file.flush
-      ObjectSpace.define_finalizer(@logger, Proc.new {@logger.info "Application (pid=#{$$}) stopped at #{DateTime.now}\n\n"})
-      @config[:db].each_value { |db| db.loggers = [@logger] }
+      self.verify_config
+      if @config[:log][:file]
+        @log_file = File.open(@config[:log][:file], File::WRONLY | File::APPEND | File::CREAT)
+        @logger = Alfa::Logger.new(@log_file)
+        str = "Application (pid=#{$$}) started at #{DateTime.now}"
+        @logger.info "#{'='*str.length}\n#{str}"
+        @logger.info "  PROJECT_ROOT: #{@config[:project_root]}"
+        @logger.info "  DOCUMENT_ROOT: #{@config[:document_root]}\n"
+        @log_file.flush
+        ObjectSpace.define_finalizer(@logger, Proc.new {@logger.info "Application (pid=#{$$}) stopped at #{DateTime.now}\n\n"})
+        @config[:db].each_value { |db| db[:instance].loggers = [@logger] }
+      else
+        @logger = Alfa::NullLogger.new
+      end
       @inited = true
     end
 
-    def self.load_database path
-      Kernel.require path
+
+    def self.load_tasks
+      VARS[:rakeapp_instance] = self
+      require 'alfa/tasks'
     end
 
+
+    def self.verify_config
+      raise Exceptions::E001 unless @config[:project_root]
+    end
   end
 end

data/lib/alfa/cli_application.rb

@@ -6,8 +6,5 @@ require 'alfa/tfile'
 
 module Alfa
   class CliApplication < Alfa::Application
-    def self.load_tasks
-      Kernel.load 'alfa/tasks/assets.rake'
-    end
   end
 end

data/lib/alfa/config.rb

@@ -1,11 +1,24 @@
 module Alfa
   class Config < ::Hash
-    #attr_accessor :project_root, :document_root, :db
 
     def initialize
       self[:db] = {}
       self[:log] = {}
     end
 
+    def []=(key, value)
+      if [:db, :log].include? key
+        raise "key :#{key} should include Enumerable" unless value.class.included_modules.include? Enumerable
+      end
+      super
+    end
+
+    def store(key, value)
+      if [:db, :log].include? key
+        raise "key :#{key} should include Enumerable" unless value.class.included_modules.include? Enumerable
+      end
+      super
+    end
+
   end
 end

data/lib/alfa/exceptions.rb

@@ -1,4 +1,12 @@
 module Alfa
-  class RouteException404 < StandardError
+  module Exceptions
+    # Route not found
+    class Route404 < StandardError; end
+
+    # Application's config.project_root required
+    class E001 < StandardError; end
+
+    # WebApplication's config.document_root required
+    class E002 < StandardError; end
   end
 end

data/lib/alfa/logger.rb

@@ -1,21 +1,41 @@
 require 'logger'
+require 'weakref'
+require 'alfa/support'
 
 module Alfa
+  class NullLogger
+    def portion(*args, &block)
+      l = WeakRef.new(self.class.new)
+      yield(l)
+    end
+
+    def info(*args)
+    end
+
+    def <<(*args)
+    end
+  end
+
+
   class Logger < ::Logger
 
     def initialize(logdev, shift_age = 0, shift_size = 1048576)
       super
+      @logdev = logdev
       @formatter = Formatter.new
     end
 
-    def portion(&block)
+    def portion(kwargs={}, &block)
       io = VirtualIO.new
-      l = ::Logger.new(io)
+      l = Logger.new(io)
       l.formatter = @formatter
       yield(l)
       self << io.join
-      l = nil
-      io = nil
+      flush if kwargs[:sync]
+    end
+
+    def flush
+      @logdev.flush #if @logdev.respond_to?(:flush)
     end
 
     private
@@ -27,6 +47,9 @@ module Alfa
 
       def close
       end
+
+      def flush
+      end
     end
 
     class Formatter < ::Logger::Formatter

data/lib/alfa/router.rb

@@ -1,6 +1,10 @@
 module Alfa
   class Router
 
+    class << self
+      attr_accessor :apps_dir
+    end
+
     # initialize class variables
     @routes = []
     @cursor = @routes
@@ -11,10 +15,6 @@ module Alfa
     def self.call &block
     end
 
-    def self.set_apps_dir dir
-      @apps_dir = dir
-    end
-
 
     def self.context options = {}, &block
       new_routes_container = []
@@ -32,7 +32,8 @@ module Alfa
 
 
     def self.reset
-      @routes = []
+      @routes.clear
+      @apps_dir = nil
     end
 
     # Set routes
@@ -61,18 +62,31 @@ module Alfa
     #   mount '/admin/', :admin
     # all requests to site.com/ and nested (site.com/*) will be sent to application 'frontend' (/apps/frontend)
     #   mount '/', :frontend
-    def self.mount path, app, options = {}
+    def self.mount path, app = nil, options = {}
+      if path.is_a?(Hash) && app == nil
+        path, a = path.first.to_a
+        app = a.to_sym
+      end
       @mounts << {:path => path, :app => app, :options => options}
       if @apps_dir
         self.context :app => app do
-          require File.join(@apps_dir, app.to_s, 'routes')
+          Kernel.load File.join(@apps_dir, app.to_s, 'routes.rb')
         end
       end
     end
 
     # Sets route rule
     def self.route rule, options = {}
-      @cursor << {:rule => rule, :options => options}
+      if rule.is_a?(Hash)
+        r, o = rule.to_a.first
+        options = rule.dup
+        options.delete(r)
+        raise 'Expected hash rule have controller#action format' unless o.include? '#'
+        c, a = o.split('#')
+        @cursor << {:rule => r, :options => options.merge({:controller => c.to_sym, :action => a.to_sym})}
+      else
+        @cursor << {:rule => rule, :options => options}
+      end
       #puts "set rule '#{rule}', routes = #{@routes}"
     end
 
@@ -106,7 +120,7 @@ module Alfa
         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
+            pares[rule_segment[1..-1].to_sym] = url_segment.to_sym
           elsif (rule_segment == url_segment) || (rule_segment == '*' && url_segment =~ /^[a-z0-9_]+$/) || (rule_segment == nil && skip_flag) || rule_segment == '**'
           else
             fail_flag = true
@@ -140,7 +154,7 @@ module Alfa
               r[:options][:app] = route[:context][:app][:app]
               return r, params if is_success
             end
-            raise Alfa::RouteException404
+            raise Alfa::Exceptions::Route404
           end
           # else - ???
         else
@@ -148,7 +162,7 @@ module Alfa
           return route, params if is_success
         end
       end
-      raise Alfa::RouteException404
+      raise Alfa::Exceptions::Route404
     end
 
   end

data/lib/alfa/support.rb

@@ -19,7 +19,7 @@ module Alfa
         @inheritable_attributes
       end
 
-      def inherited(subclass)
+      def inherited(subclass) # ruby hook
         @inheritable_attributes.each do |inheritable_attribute|
           instance_var = "@#{inheritable_attribute}"
           subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
@@ -28,10 +28,17 @@ module Alfa
     end
   end
 
-  class Support
-    def self.capitalize_name arg
+  module Support
+    extend self
+
+    def capitalize_name(arg)
       arg.to_s.split('/').last.split('_').map(&:capitalize).join
     end
+
+    def parse_arguments(*arguments)
+      return arguments[0..-2], arguments.last if arguments.last.is_a?(Hash)
+      return arguments, {}
+    end
   end
 
 end

data/lib/alfa/tasks.rb

@@ -0,0 +1,2 @@
+load 'alfa/tasks/assets.rake'
+load 'alfa/tasks/db.rake'

data/lib/alfa/tfile.rb

@@ -15,11 +15,10 @@ module Alfa
       def allowed_options
         @allowed_options ||= %w(absfile projfile url).map(&:to_sym)
       end
-      def inherited(subclass)
+      def inherited(subclass) # ruby hook
         subclass.instance_variable_set(:@project_root, instance_variable_get(:@project_root))
         subclass.instance_variable_set(:@document_root, instance_variable_get(:@document_root))
       end
-
     end
 
     attr_reader :absfile, :absdir, :basename, :dirname

data/lib/alfa/web_application.rb

@@ -10,9 +10,6 @@ require 'ruty/bugfix'
 require 'ruty/upgrade'
 require 'ruty/tags/resources'
 
-Encoding.default_external='utf-8'
-Encoding.default_internal='utf-8'
-
 module Alfa
   class WebApplication < Alfa::Application
 
@@ -26,9 +23,10 @@ module Alfa
     end
 
     def self.init!
-      Alfa::Router.set_apps_dir File.join(PROJECT_ROOT, 'apps')
-      require File.join(PROJECT_ROOT, 'config/routes')
       super
+      Alfa::Router.reset
+      Alfa::Router.apps_dir = File.join(@config[:project_root], 'apps')
+      load File.join(@config[:project_root], 'config/routes.rb')
     end
 
     # main rack routine
@@ -37,8 +35,8 @@ module Alfa
       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] }
+      @logger.portion(:sync=>true) do |l|
+        @config[:db].each_value { |db| db[:instance].loggers = [l] }
         @env = env
         @bputs = []
         headers = {"Content-Type" => 'text/html; charset=utf-8'}
@@ -50,7 +48,7 @@ module Alfa
           #@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']
+          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__))
@@ -66,8 +64,7 @@ module Alfa
             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 = self.invoke_controller_check_action(app_sym, c_sym, a_sym)
             controller.__send__(a_sym)
             data = controller._instance_variables_hash
             Ruty::Tags::RequireStyle.clean_cache
@@ -75,14 +72,14 @@ module Alfa
             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
+        rescue Alfa::Exceptions::Route404 => 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>")}"
+          body = "Error occured: #{e.message} at #{e.backtrace.first}<br>Full backtrace:<br>\n#{e.backtrace.join("<br>\n")}"
         end
         if t_sym == :default
           #debug_info = '<hr>Queries:<br>' + @logger.logs.map { |log|
@@ -96,8 +93,6 @@ module Alfa
         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
 
@@ -114,10 +109,18 @@ module Alfa
 
   # private section
 
-    def self.invoke_controller application, controller
+    def self.verify_config
+      super
+      raise Exceptions::E002.new unless @config[:document_root]
+    end
+
+    def self.invoke_controller_check_action application, controller, action
       @controllers ||= {}
-      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
+      require File.join(@config[:project_root], 'apps', application.to_s, 'controllers', controller.to_s)
+      # @todo put klass to controllers cache
+      klass = Kernel.const_get(Alfa::Support.capitalize_name(controller)+'Controller')
+      raise Exceptions::Route404 unless klass.instance_methods(false).include?(action)
+      @controllers[[application, controller]] ||= klass.new
     end
 
     def self.render_template app, template, data = {}
@@ -131,7 +134,7 @@ module Alfa
     end
 
     def self.loader
-      @loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(PROJECT_ROOT, 'apps'))
+      @loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(@config[:project_root], 'apps'))
     end
 
   end

data/test/data/test_router/1/apps/backend/routes.rb

@@ -0,0 +1,4 @@
+Alfa::Router.draw do
+  route '/', :controller => :main, :action => :index, :layout => :index
+  route '/:controller', :action => :index
+end

data/test/data/test_router/1/apps/frontend/routes.rb

@@ -0,0 +1,6 @@
+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

data/test/data/test_router/2/apps/backend/routes.rb

@@ -0,0 +1,4 @@
+Alfa::Router.draw do
+  route '/' => 'main#index', :layout => :index
+  route '/:controller', :action => :index
+end

data/test/data/test_router/2/apps/frontend/routes.rb

@@ -0,0 +1,6 @@
+Alfa::Router.draw do
+  route '/' => 'main#index', :layout => :index
+  route '/:action', :controller => :main, :layout => :internal
+  route '/:controller/:action', :layout => :internal
+  route '/:controller/:action/:id', :layout => :internal
+end

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

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

data/test/data/test_web_application/apps/frontend/controllers/kfk.rb

@@ -0,0 +1,9 @@
+class KfkController < Alfa::Controller
+  def index
+
+  end
+
+  def bar
+
+  end
+end

data/test/data/test_web_application/apps/frontend/routes.rb

@@ -0,0 +1,4 @@
+Alfa::WebApplication.routes.draw do
+  route '/' => 'kfk#index'
+  route '/:action', :controller => :kfk
+end

data/test/data/test_web_application/config/routes.rb

@@ -0,0 +1,3 @@
+Alfa::WebApplication.routes.draw do
+  mount '/' => :frontend
+end

data/test/test_application.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'alfa/application'
+require 'alfa/config'
+
+class AlfaApplicationTest < Test::Unit::TestCase
+  def test_01 # base test
+    assert Alfa::VARS.is_a?(Hash), "Alfa::VARS expected to be a Hash"
+    assert_raise NoMethodError do
+      application = Alfa::Application.new
+    end
+    assert Alfa::Application.respond_to?(:init!)
+    assert Alfa::Application.respond_to?(:load_tasks)
+    assert Alfa::Application.respond_to?(:config)
+  end
+
+  def test_02 # Alfa::Application.config
+    assert Alfa::Application.config.is_a?(Alfa::Config)
+    Alfa::Application.config :foo => 1
+    assert_equal(1, Alfa::Application.config[:foo])
+    Alfa::Application.config[:bar] = 2
+    assert_equal(2, Alfa::Application.config[:bar])
+  end
+
+  # test config.project_root
+  def test_03
+    assert_raise Alfa::Exceptions::E001, "Application requires config.project_root" do
+      Alfa::Application.init!
+    end
+    assert_raise Alfa::Exceptions::E001, "Application's project_root should not be nil" do
+      Alfa::Application.config[:project_root] = nil
+      Alfa::Application.init!
+    end
+    assert_nothing_raised Exception, "Application should silent init when project_root is set" do
+      Alfa::Application.config[:project_root] = File.expand_path('../data/test_application', __FILE__)
+      Alfa::Application.init!
+    end
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'alfa/config'
+
+class AlfaConfigTest < Test::Unit::TestCase
+  def test_01
+    config = Alfa::Config.new
+    assert config.is_a?(Hash)
+    assert config[:db].is_a?(Hash)
+    assert config[:log].is_a?(Hash)
+    assert_raise RuntimeError do
+      config[:db] = nil
+    end
+    assert_raise RuntimeError do
+      config.store(:db, nil)
+    end
+    assert_raise RuntimeError do
+      config[:log] = nil
+    end
+    assert_raise RuntimeError do
+      config.store(:log, nil)
+    end
+    assert_equal({:db=>{}, :log=>{}}, config)
+    config[:foo] = 1
+    assert_equal({:db=>{}, :log=>{}, :foo=>1}, config)
+  end
+end

data/test/test_controller.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'alfa/controller'
+
+class TestAlfaController < Test::Unit::TestCase
+  def test_01
+    eval <<EOL
+class Z < Alfa::Controller
+  def some_action
+    @foo = :bar
+  end
+  def other_action
+    @fuu = :baz
+  end
+end
+EOL
+    z = Z.new
+    z.some_action
+    assert_equal({:foo=>:bar}, z._instance_variables_hash)
+    z.other_action
+    assert_equal({:foo=>:bar, :fuu=>:baz}, z._instance_variables_hash)
+  end
+end

data/test/test_logger.rb

@@ -0,0 +1,97 @@
+require 'test/unit'
+require 'alfa/logger'
+require 'tempfile'
+
+class TestAlfaLogger < Test::Unit::TestCase
+  # test of nested Formatter class
+  def test_01
+    formatter = Alfa::Logger::Formatter.new
+    time = Time.now
+    progname = 'unknown'
+    assert_equal("Hello\n", formatter.call(Logger::Severity::DEBUG, time, progname, 'Hello'))
+    assert_equal("Hello\n", formatter.call(Logger::Severity::INFO, time, progname, 'Hello'))
+    assert_equal("Hello\n", formatter.call(Logger::Severity::WARN, time, progname, 'Hello'))
+    assert_equal("Hello\n", formatter.call(Logger::Severity::ERROR, time, progname, 'Hello'))
+    assert_equal("Hello\n", formatter.call(Logger::Severity::FATAL, time, progname, 'Hello'))
+    assert_equal("Hello\n", formatter.call(Logger::Severity::UNKNOWN, time, progname, 'Hello'))
+  end
+
+  # test of nested VirtualIO class
+  def test_02
+    io = Alfa::Logger::VirtualIO.new
+    assert io.respond_to?(:write)
+    assert io.respond_to?(:close)
+    io.write("Hello")
+    io.write("World")
+    assert_equal(["Hello", "World"], io)
+  end
+
+  # base test with virtual receiver
+  def test_03
+    io = Alfa::Logger::VirtualIO.new
+    logger = Alfa::Logger.new(io)
+    logger.info("Hello")
+    logger.info("World")
+    logger << "zz"
+    assert_equal(["Hello\n", "World\n", "zz"], io)
+  end
+
+  # base test with real file
+  def test_04
+    Tempfile.open('loggertest_04_') do |f|
+      logger = Alfa::Logger.new(f)
+      logger.info "Hello"
+      logger.info "World"
+      logger << "zz"
+      f.rewind
+      assert_equal("Hello\nWorld\nzz", f.read)
+    end
+  end
+
+  # simulate 2 threads with virtual receiver
+  # threads write to receiver in their close order
+  def test_05
+    io = Alfa::Logger::VirtualIO.new
+    logger = Alfa::Logger.new(io)
+    logger.portion do |l1|
+      l1.info "Hello"
+      logger.portion do |l2|
+        l2.info "Baramba"
+        l2.info "Caramba!"
+        l2 << "\n"
+        # first closed thread -> first write to receiver
+      end
+      l1.info "World"
+      l1 << "\n"
+      # last closed thread -> last write to receiver
+    end
+    assert_equal(["Baramba\nCaramba!\n\n", "Hello\nWorld\n\n"], io)
+  end
+
+  # simulate 2 threads with real file
+  # threads write to receiver in their close order
+  def test_06
+    Tempfile.open('loggertest_06_') do |f|
+      logger = Alfa::Logger.new(f)
+      logger.portion do |l1|
+        l1.info "Hello"
+        logger.portion do |l2|
+          l2.info "Baramba"
+          l2.info "Caramba!"
+          l2 << "\n"
+          # first closed thread -> first write to receiver
+        end
+        l1.info "World"
+        l1 << "\n"
+        # last closed thread -> last write to receiver
+      end
+      f.rewind
+      assert_equal("Baramba\nCaramba!\n\nHello\nWorld\n\n", f.read)
+    end
+  end
+
+  # NullLogger
+  def test_07
+    assert Alfa::NullLogger.instance_methods.include?(:portion)
+  end
+end

data/test/test_router.rb

@@ -5,20 +5,20 @@ 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, {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, {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, {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, {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'))
@@ -79,6 +79,7 @@ class AlfaRouterTest < Test::Unit::TestCase
 
   # Checks right order of draw and mounted rules
   def test_03 # Router's internal routes struct
+    Alfa::Router.reset
     prepare_router
     assert_equal(
         [
@@ -103,30 +104,111 @@ class AlfaRouterTest < Test::Unit::TestCase
 
 
   def test_04 # mount
+    Alfa::Router.reset
     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: '/: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
+    assert_equal([{rule: '/:controller', options: {app: :admin, action: :index}}, {controller: :foo}], Alfa::Router.find_route('/admin/foo'))
+    assert_raise Alfa::Exceptions::Route404 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
 
+  # Checks right order of draw and mounted rules
+  def test_05
+    Alfa::Router.reset
+    Alfa::Router.apps_dir = File.expand_path('../data/test_router/1/apps', __FILE__)
+    load File.expand_path('../data/test_router/1/config/routes.rb', __FILE__)
+    assert_equal(
+        [
+            {:rule=>"/~assets/:path**", :options=>{:type=>:asset}},
+            {:context=>{:app=>{:path=>"/admin/", :app=>:backend, :options=>{}}},
+             :routes=>[
+                 {:rule=>"/", :options=>{:controller=>:main, :action=>:index, :layout=>:index}},
+                 {: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
+
   # this test loads routes.rb files from data/test_router directory to simulate real project skeletron
-  def test_05 # load_from_files
+  def test_06 # load_from_files
+    Alfa::Router.reset
+    Alfa::Router.apps_dir = File.expand_path('../data/test_router/1/apps', __FILE__)
+    load File.expand_path('../data/test_router/1/config/routes.rb', __FILE__)
+    #puts Alfa::Router.instance_variable_get(:@routes).inspect
     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_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: :backend, controller: :main, action: :index, layout: :index}}, {}], Alfa::Router.find_route('/admin/'))
+    assert_equal([{rule: '/:controller', options: {app: :backend, action: :index}}, {controller: :foo}], Alfa::Router.find_route('/admin/foo'))
+  end
+
+  # alternative route format 'url' => 'controller#action'
+  def test_07
+    Alfa::Router.reset
+    Alfa::Router.draw do
+      route '/' => 'default#index'
+      route '/zoo' => 'default#zoo', :layout => :default
+      mount '/admin' => :backend
+      Alfa::Router.context :app => :backend do
+        route '/' => 'kfk#index', :layout => :fantastic
+      end
+    end
+    #puts Alfa::Router.instance_variable_get(:@routes).inspect
+    assert_equal(
+        [
+            {:rule=>"/~assets/:path**", :options=>{:type=>:asset}},
+            {:rule=>'/', :options=>{:controller=>:default, :action=>:index}},
+            {:rule=>'/zoo', :options=>{:controller=>:default, :action=>:zoo, :layout => :default}},
+            {:context=>{:app=>{:path=>'/admin/', :app=>:backend, :options=>{}}},
+             :routes=>[
+                 {:rule=>'/', :options=>{:controller=>:kfk, :action=>:index, :layout=>:fantastic}}
+             ]},
+        ],
+        Alfa::Router.instance_variable_get(:@routes)
+    )
   end
 
+  # alternative route format with real files
+  def test_08
+    Alfa::Router.reset
+    Alfa::Router.apps_dir = File.expand_path('../data/test_router/2/apps', __FILE__)
+    load File.expand_path('../data/test_router/2/config/routes.rb', __FILE__)
+    assert_equal(
+        [
+            {:rule=>"/~assets/:path**", :options=>{:type=>:asset}},
+            {:context=>{:app=>{:path=>"/admin/", :app=>:backend, :options=>{}}},
+             :routes=>[
+                 {:rule=>"/", :options=>{:controller=>:main, :action=>:index, :layout=>:index}},
+                 {: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)
+    )
+    #puts Alfa::Router.instance_variable_get(:@routes).inspect
+  end
 end

data/test/test_support.rb

@@ -23,4 +23,16 @@ class AlfaSupportTest < Test::Unit::TestCase
     assert_equal('localhost', DB1.host)
     assert_equal('otherhost', DB2.host)
   end
+
+  def test_parse_arguments
+    assert_equal([[], {}], Alfa::Support.parse_arguments())
+    assert_equal([[1, 2], {}], Alfa::Support.parse_arguments(1, 2))
+    assert_equal([[1, 2], {3=>4}], Alfa::Support.parse_arguments(1, 2, 3=>4))
+    assert_equal([[1, 2], {3=>4}], Alfa::Support.parse_arguments(1, 2, {3=>4}))
+    assert_equal([[], {3=>4}], Alfa::Support.parse_arguments(3=>4))
+    assert_equal([[1, 2], {3=>4, 5=>6}], Alfa::Support.parse_arguments(1, 2, 3=>4, 5=>6))
+    assert_equal([[], {3=>4, 5=>6}], Alfa::Support.parse_arguments(3=>4, 5=>6))
+    assert_equal([[[]], {}], Alfa::Support.parse_arguments([]))
+    assert_equal([[], {}], Alfa::Support.parse_arguments({}))
+  end
 end

data/test/test_web_application.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'alfa/web_application'
+
+class TestAlfaWebApplication < Test::Unit::TestCase
+  # basics
+  def test_01
+    assert Alfa::WebApplication.respond_to?(:call), "WebApplication should be callable for Rack"
+    assert Alfa::WebApplication.ancestors.include?(Alfa::Application), "WebApplication should be subclass of Application"
+  end
+
+
+  def test_02
+    Alfa::WebApplication.config[:project_root] = File.expand_path('../data/test_web_application', __FILE__)
+    assert_raise Alfa::Exceptions::E002, "WebApplication requires config.document_root" do
+      Alfa::WebApplication.config.delete(:document_root)
+      Alfa::WebApplication.init!
+    end
+    assert_raise Alfa::Exceptions::E002, "WebApplication's document_root should not be nil" do
+      Alfa::WebApplication.config[:document_root] = nil
+      Alfa::WebApplication.init!
+    end
+    assert_nothing_raised Exception do
+      Alfa::WebApplication.config[:document_root] = File.expand_path('../data/test_web_application/public', __FILE__)
+      Alfa::WebApplication.init!
+    end
+  end
+
+
+  def test_03
+    Alfa::WebApplication.config[:project_root] = File.expand_path('../data/test_web_application', __FILE__)
+    Alfa::WebApplication.config[:document_root] = File.expand_path('../data/test_web_application/public', __FILE__)
+    Alfa::WebApplication.init!
+    #puts Alfa::Router.instance_variable_get(:@routes).inspect
+    assert_equal(200, Alfa::WebApplication.call({'PATH_INFO' => '/'})[0])
+    assert_equal(404, Alfa::WebApplication.call({'PATH_INFO' => '/404'})[0])
+    assert_equal(200, Alfa::WebApplication.call({'PATH_INFO' => '/bar'})[0])
+    assert_equal(404, Alfa::WebApplication.call({'PATH_INFO' => '/methods'})[0])
+    assert_equal(404, Alfa::WebApplication.call({'PATH_INFO' => '/inspect'})[0])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alfa
 version: !ruby/object:Gem::Version
-  version: 0.0.2.pre
+  version: 0.0.4.pre
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-15 00:00:00.000000000 Z
+date: 2012-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rvm
@@ -115,32 +115,46 @@ extra_rdoc_files: []
 files:
 - lib/alfa/commands/new.rb
 - lib/alfa/database/mysql.rb
-- lib/alfa/exceptions.rb
 - lib/alfa/models/base.rb
 - lib/alfa/models/base_sql.rb
 - lib/alfa/models/dummy.rb
 - lib/alfa/models/mysql.rb
-- lib/alfa/application.rb
-- lib/alfa/cli_application.rb
-- lib/alfa/config.rb
 - lib/alfa/controller.rb
 - lib/alfa/database.rb
-- lib/alfa/logger.rb
 - lib/alfa/models.rb
 - lib/alfa/query_logger.rb
+- lib/alfa/application.rb
+- lib/alfa/cli_application.rb
+- lib/alfa/config.rb
+- lib/alfa/exceptions.rb
+- lib/alfa/logger.rb
+- lib/alfa/router.rb
 - lib/alfa/support.rb
+- lib/alfa/tasks.rb
 - lib/alfa/tfile.rb
-- lib/alfa/router.rb
 - lib/alfa/web_application.rb
 - lib/ruty/tags/resources.rb
 - lib/ruty/bugfix.rb
 - lib/ruty/upgrade.rb
 - lib/alfa.rb
 - test/test_alfa.rb
-- test/test_support.rb
 - test/test_tfile.rb
-- test/data/test_router/config/routes.rb
+- test/test_controller.rb
+- test/test_logger.rb
 - test/test_router.rb
+- test/test_support.rb
+- test/test_web_application.rb
+- test/data/test_router/1/apps/backend/routes.rb
+- test/data/test_router/1/apps/frontend/routes.rb
+- test/data/test_router/1/config/routes.rb
+- test/data/test_router/2/apps/backend/routes.rb
+- test/data/test_router/2/apps/frontend/routes.rb
+- test/data/test_router/2/config/routes.rb
+- test/data/test_web_application/apps/frontend/controllers/kfk.rb
+- test/data/test_web_application/apps/frontend/routes.rb
+- test/data/test_web_application/config/routes.rb
+- test/test_application.rb
+- test/test_config.rb
 - assets/css/960gs/960.css
 - assets/css/960gs/960_12_col.css
 - assets/css/960gs/960_12_col_rtl.css