alfa 0.0.4.pre → 0.0.5.pre

data/lib/alfa/web_application.rb

@@ -1,22 +1,32 @@
-# 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'
+require 'alfa/ruty'
+require 'alfa/user'
+require 'rack/utils'
+require 'rack/request'
+require 'rack/file_alfa'
+require 'digest/md5'
+require 'securerandom'
+require 'haml'
+require 'alfa/template-inheritance'
+require 'tilt/alfa_patch'
+require 'haml/alfa_patch'
 
 module Alfa
   class WebApplication < Alfa::Application
 
-    @namespaces_stack = []
     @bputs = []
+    @haml_templates = {}
 
-    def self.inherited subclass
+    class << self
+      attr_reader :request
+    end
+
+    def self.inherited(subclass)
       instance_variables.each do |var|
         subclass.instance_variable_set(var, instance_variable_get(var))
       end
@@ -27,56 +37,74 @@ module Alfa
       Alfa::Router.reset
       Alfa::Router.apps_dir = File.join(@config[:project_root], 'apps')
       load File.join(@config[:project_root], 'config/routes.rb')
+      TemplateInheritance.logger = @logger
+      Alfa.GROUPS = @config[:groups]
     end
 
-    # main rack routine
-    def self.call env
+    # main Rack routine
+    def self.call(env, &block)
       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(:sync=>true) do |l|
         @config[:db].each_value { |db| db[:instance].loggers = [l] }
-        @env = env
+        TemplateInheritance.logger = l
         @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']}"
+          # l.info "  HTTP_HOST: #{env['HTTP_HOST']}"
+          # l.info "  HTTP_ACCEPT: #{env['HTTP_ACCEPT']}"
+          # l.info "  HTTP_ACCEPT_LANGUAGE: #{env['HTTP_ACCEPT_LANGUAGE']}"
+          # l.info "  PATH_INFO: #{env['PATH_INFO']}"
           response_code = 200
-          route, params = self.routes.find_route(@env['PATH_INFO'])
+          route, params = self.routes.find_route(Rack::Utils.unescape(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__))
+            realpath = File.expand_path('../../../assets/' + params[:path], __FILE__)
+            body = File.read(realpath)
             case File.extname(params[:path]).downcase
               when '.js'
-                headers = {'Content-Type' => 'application/javascript; charset=utf-8'}
+                headers['Content-Type'] = 'application/javascript; charset=utf-8'
               when '.css'
-                headers = {'Content-Type' => 'text/css; charset=utf-8'}
+                headers['Content-Type'] = 'text/css; charset=utf-8'
               else
             end
+            headers['Last-Modified'] = File.mtime(realpath).httpdate
+            headers['Cache-Control'] = 'max-age=2592000'
+            headers['Expires'] = (Time.now + 2592000).httpdate
           else
+            request = Rack::Request.new(env) # weakref?
             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_check_action(app_sym, c_sym, a_sym)
+            controller = self.invoke_controller(app_sym, c_sym)
+            raise Exceptions::Route404 unless controller.class.instance_methods(false).include?(a_sym)
+            controller._clear_instance_variables # cleanup
+            controller.application = self
+            controller.request = request
+            controller.app_sym = app_sym
+            controller.c_sym = c_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'}
+            Ruty::Tags::RequireStyle.clean_cache # cleanup
+            Ruty::Tags::RequireScript.clean_cache # cleanup
+            content = self.render_template(app_sym, c_sym, a_sym, controller, data, &block)
+            body = self.render_layout(app_sym.to_s, l_sym.to_s, data.merge({:@body => content}))
+            headers["Content-Type"] = 'text/html; charset=utf-8'
           end
         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 Exceptions::HttpRedirect => e
+          response_code = e.code
+          headers['Location'] = e.url.to_s
+          body = ''
         rescue Exception => e
           response_code = 500
           body = "Error occured: #{e.message} at #{e.backtrace.first}<br>Full backtrace:<br>\n#{e.backtrace.join("<br>\n")}"
@@ -102,39 +130,85 @@ module Alfa
     end
 
 
+    def self.rackup(builder)
+      builder.use Rack::Session::Cookie
+      if @config[:serve_static]
+        builder.run Rack::Cascade.new([
+          Rack::FileAlfa.new(@config[:document_root]),
+          self,
+        ])
+      else
+        builder.run self
+      end
+    end
+
+
     def self.bputs arg
       @bputs << "#{arg}\n"
     end
 
 
+    def self.redirect(url, code=302)
+      raise Exceptions::HttpRedirect.new(url, code)
+    end
+
   # private section
 
     def self.verify_config
       super
-      raise Exceptions::E002.new unless @config[:document_root]
+      raise Exceptions::E002.new('config[:document_root] should be defined') unless @config[:document_root]
+      raise Exceptions::E002.new('config[:templates_priority] should be defined') unless @config[:templates_priority]
+      raise Exceptions::E001.new('config[:groups] should be a hash') unless @config[:groups].is_a?(::Hash)
+      @config[:groups][:public] = [] unless @config[:groups][:public]
     end
 
-    def self.invoke_controller_check_action application, controller, action
-      @controllers ||= {}
-      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
+    def self.invoke_controller(a_sym, c_sym)
+      load File.join(@config[:project_root], 'apps', a_sym.to_s, 'controllers', c_sym.to_s + '.rb')
+      klass_name = Alfa::Support.camelcase_name(c_sym)+'Controller'
+      klass = Kernel.const_get(klass_name) # weakref?
+      instance = klass.new
+      Object.module_eval{remove_const(klass_name)}
+      return instance
     end
 
-    def self.render_template app, template, data = {}
-      t = self.loader.get_template File.join(app, 'templates', template)
-      t.render data
+    def self.render_template(app_sym, c_sym, a_sym, controller, data = {}, &block)
+      render(file: File.join(@config[:project_root], 'apps', app_sym.to_s, 'templates', c_sym.to_s, a_sym.to_s), controller: controller, data: data, &block)
+    end
+
+    def self.render_layout(app, layout, data = {})
+      render(file: File.join(@config[:project_root], 'apps', app, 'layouts', layout.to_s), data: data)
+    end
+
+    def self.render(file: nil, controller: nil, data: {})
+      @config[:templates_priority].each do |ext|
+        f = "#{file}.#{ext}"
+        if File.exist?(f)
+          case ext
+            when :haml
+              template = self.haml_template(f, controller)
+              yield(controller, template) if block_given? # required only for thread isolation test
+              return template.render data
+            when :tpl
+              Ruty::AUX_VARS[:controller] = controller
+              template = self.ruty_loader.get_template(f)
+              return template.render data
+            else
+              raise StandardError.new("Unknown template type: #{ext}")
+          end
+          break
+        end
+      end
+      raise StandardError.new("Can't find template #{file}.[#{@config[:templates_priority].join('|')}]")
     end
 
-    def self.render_layout app, layout, data = {}
-      t = self.loader.get_template File.join(app, 'layouts', layout)
-      t.render data
+    def self.ruty_loader
+      @ruty_loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(@config[:project_root], 'apps'))
     end
 
-    def self.loader
-      @loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(@config[:project_root], 'apps'))
+    def self.haml_template(file, controller)
+      # @haml_templates[file.to_sym] ||= TemplateInheritance::Template.new(file)
+      scope = TemplateInheritance::RenderScope.new(controller)
+      TemplateInheritance::Template.new(file, scope)
     end
 
   end

data/lib/haml/alfa_patch.rb

@@ -0,0 +1,25 @@
+module Haml
+  class Options
+    @defaults = @defaults.merge({:raw_interpolated_tags => []})
+    attr_accessor :raw_interpolated_tags
+  end
+
+  module Util
+    def unescape_interpolation(str, escape_html = nil)
+      res = ''
+      rest = Haml::Util.handle_interpolation str.dump do |scan|
+        escapes = (scan[2].size - 1) / 2
+        res << scan.matched[0...-3 - escapes]
+        if escapes % 2 == 1
+          res << '#{'
+        else
+          content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
+          tag = content[/(\S+\s?){1}/].strip.to_sym
+          content = "Haml::Helpers.html_escape((#{content}))" if escape_html && !@options[:raw_interpolated_tags].include?(tag)
+          res << '#{' + content + "}"# Use eval to get rid of string escapes
+        end
+      end
+      res + rest
+    end
+  end
+end

data/lib/rack/file_alfa.rb

@@ -0,0 +1,11 @@
+require 'rack/file'
+
+module Rack
+  class FileAlfa < File
+    #Deny .htaccess files
+    def call(env)
+      return fail(404, 'Not found') if env['PATH_INFO'].split(SEPS).last == '.htaccess'
+      super
+    end
+  end
+end

data/lib/ruty/tags/href.rb

@@ -0,0 +1,12 @@
+# HREF
+
+class Ruty::Tags::Href < Ruty::Tag
+  def initialize(parser, argstring)
+    @argstring = argstring
+  end
+  def render_node(context, stream)
+    stream << Ruty::AUX_VARS[:controller].href(@argstring)
+  end
+  Ruty::Tags.register(self, :href)
+  Ruty::Tags.register(self, :href_to)
+end

data/lib/ruty/upgrade.rb

@@ -1,4 +1,4 @@
-# escape variables by default
+# Escaping variables by default
 # {{ variable }} transforms to {{ variable|escape }}
 # {{ variable|raw }} transforms to {{ variable }}
 module Ruty

data/lib/template-inheritance/alfa_bugfix.rb

@@ -0,0 +1,15 @@
+# Monkeypatch bugfix for gem TemplateInheritance v0.3.1
+# Without this patch the line 10 in template-inheritance/exts/tilt.rb
+#   klass.send(:remove_method, :initialize_engine)
+# raises error during initialization because Tilt 2.0.0 have no method Tilt::HamlTemplate.initialize_engine
+# Correct syntax in tilt.rb should be:
+#   klass.send(:remove_method, :initialize_engine) if klass.respond_to?(:initialize_engine)
+module Tilt
+  class HamlTemplate
+    unless self.respond_to?(:initialize_engine)
+      def initialize_engine
+      end
+    end
+  end
+end
+# End of patch

data/lib/template-inheritance/alfa_helpers.rb

@@ -0,0 +1,93 @@
+# Monkeypatch functionalfix for gem TemplateInheritance v0.3.1
+module TemplateInheritance
+  class Template
+    attr_writer :resources
+    def resources
+      @resources ||= {styles: [], scripts:[], added_scripts: []}
+    end
+
+    def instantiate_supertemplate
+      supertemplate = self.class.new(self.supertemplate, self.scope)
+      supertemplate.blocks = self.blocks
+      supertemplate.resources = self.resources
+      supertemplate
+    end
+  end
+
+
+  class RenderScope
+    attr_reader :controller
+
+    def initialize(controller = nil)
+      @controller = controller
+    end
+  end
+
+
+  module TemplateHelpers
+    def require_style(src, *modes)
+      case src
+        when :'960gs', '960gs'
+          require_style '/~assets/css/960gs/reset.css' if modes.include?(:reset)
+          require_style '/~assets/css/960gs/text.css' if modes.include?(:text)
+          require_style '/~assets/css/960gs/960.css'
+        when :'960gs24', '960gs24'
+          require_style '/~assets/css/960gs/reset.css' if modes.include?(:reset)
+          require_style '/~assets/css/960gs/text.css' if modes.include?(:text)
+          require_style '/~assets/css/960gs/960_24_col.css'
+        when :alfa_classic, 'alfa_classic'
+
+        else
+          self.template.resources[:styles] << src
+      end
+    end
+
+    def styles
+      self.template.resources[:styles].uniq.map{|s|
+        if s.match(/^\/~assets\/(.*)/)
+          f = File.join(File.expand_path('../../../assets/', __FILE__), $1)
+        else
+          f = File.join(Alfa::WebApplication.config[:document_root], s)
+        end
+        mtime = File.exist?(f) ? File.mtime(f).to_i : nil
+        "<link rel=\"stylesheet\" type=\"text/css\" href=\"#{s}?#{mtime}\">\n"
+      }.join('')
+    end
+
+    def top_scripts
+
+    end
+
+    def require_script(src, type: 'text/javascript')
+      raise ArgumentError, 'src required' if src.nil?
+      self.template.resources[:scripts] << src
+    end
+
+    def add_script(type: 'text/javascript', &block)
+      self.template.resources[:scripts] << self.template.scope.capture(&block)
+    end
+
+    def scripts
+      self.template.resources[:scripts].reverse.uniq.map{|s| "<script type='text/javascript' src='#{s}'></script>\n" }.join('')
+    end
+
+    def href(*o)
+      @controller.href(*o)
+    end
+
+    def a(text, url)
+      "<a href='#{url}'>#{Haml::Helpers.html_escape(text)}</a>"
+    end
+
+    alias :link_to :a
+
+    def controller
+      @controller
+    end
+
+    def user
+      @controller.user
+    end
+  end
+end
+# End of patch

data/lib/tilt/alfa_patch.rb

@@ -0,0 +1,25 @@
+module Tilt
+  class Template
+    # This patch allows to use of @keys as well as keys
+    # Example:
+    #   template.render({:@name => 'Piter'})
+    def local_extraction(local_keys)
+      local_keys.map do |k|
+        if k.to_s =~ /\A@?[a-z_][a-zA-Z_0-9]*\z/ # this line patched
+          "#{k} = locals[#{k.inspect}]"
+        else
+          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
+        end
+      end.join("\n")
+    end
+  end
+end
+
+module TemplateInheritance
+  class Template
+    def template(options = {})
+      options = {:escape_html => true, :raw_interpolated_tags => [:a, :link_to]}.merge(options)
+      @template ||= Tilt.new(self.fullpath, nil, options)
+    end
+  end
+end

data/test/data/test_web_application/apps/admin/controllers/default.rb

@@ -0,0 +1,20 @@
+class DefaultController < Alfa::Controller
+  def test_04
+    @str = 'Admin'
+  end
+
+  def test_06
+  end
+
+  def test_08
+    @request = request
+    @env = @request.env
+    @path_info = @env['PATH_INFO']
+    session[:foo] = :baz
+    @link = href('test_08')
+  end
+
+  def test_08a
+    session[:foo] = :faz
+  end
+end

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

@@ -0,0 +1,3 @@
+Alfa::WebApplication.routes.draw do
+  route '/:action', :controller => :default
+end

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

@@ -0,0 +1,35 @@
+class DefaultController < Alfa::Controller
+  def index
+  end
+
+  def bar
+  end
+
+  def test_04
+    @str = 'Frontend'
+  end
+
+  def frontend_only
+  end
+
+  def test_06
+    @some_var = :some_value
+  end
+
+  def test_07
+    @other_var = :other_value
+  end
+
+  def test_08
+    @request = request
+    @env = @request.env
+    @path_info = @env['PATH_INFO']
+    session[:foo] = :bar
+    @link = href('test_08')
+  end
+
+  def test_08a
+    @controller = self
+    session[:foo] = :far
+  end
+end

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

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

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

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

data/test/test_controller.rb

@@ -1,5 +1,6 @@
 require 'test/unit'
 require 'alfa/controller'
+require 'alfa/exceptions'
 
 class TestAlfaController < Test::Unit::TestCase
   def test_01
@@ -15,8 +16,35 @@ end
 EOL
     z = Z.new
     z.some_action
-    assert_equal({:foo=>:bar}, z._instance_variables_hash)
+    assert_equal({:@foo=>:bar}, z._instance_variables_hash)
     z.other_action
-    assert_equal({:foo=>:bar, :fuu=>:baz}, z._instance_variables_hash)
+    assert_equal({:@foo=>:bar, :@fuu=>:baz}, z._instance_variables_hash)
+  end
+
+  # _string_to_aca
+  def test_02
+    c = Alfa::Controller.new
+    assert_equal({:action=>:foo}, c._string_to_aca('foo'))
+    assert_equal({:action=>:foo, :controller=>:default}, c._string_to_aca('default#foo'))
+    assert_equal({:app=>:admin, :controller=>:default, :action=>:foo}, c._string_to_aca('default#foo@admin'))
+    assert_equal({:app=>:admin}, c._string_to_aca('@admin'))
+    assert_raise Alfa::Exceptions::E004 do c._string_to_aca('default#foo@admi@n') end
+    assert_raise Alfa::Exceptions::E004 do c._string_to_aca('de#fault#foo@admin') end
+    assert_raise Alfa::Exceptions::E004 do c._string_to_aca('#default#f#oo@admin') end
+  end
+
+  # _extract_href_params
+  def test_03
+    c = Alfa::Controller.new
+    c.app_sym = :frontend
+    c.c_sym = :default
+    assert_equal({:app=>:frontend, :controller=>:default, :action=>:foo}, c._extract_href_params(:action=>:foo))
+    assert_equal({:app=>:frontend, :controller=>:default, :action=>:foo}, c._extract_href_params(:action=>:foo, :controller=>:default))
+    assert_equal({:app=>:frontend, :controller=>:default, :action=>:foo}, c._extract_href_params(:foo))
+    assert_equal({:app=>:frontend, :controller=>:default, :action=>:foo}, c._extract_href_params('foo'))
+    assert_equal({:app=>:frontend, :controller=>:admin, :action=>:foo}, c._extract_href_params('admin#foo'))
+    assert_equal({:app=>:zoo, :controller=>:admin, :action=>:foo}, c._extract_href_params('admin#foo', :app=>:zoo))
+    assert_equal({:app=>:zoo, :controller=>:admin, :action=>:foo}, c._extract_href_params('admin#foo@zoo'))
+    assert_equal({:app=>:admin}, c._extract_href_params(:app=>:admin))
   end
 end

data/test/test_router.rb

@@ -211,4 +211,28 @@ class AlfaRouterTest < Test::Unit::TestCase
     )
     #puts Alfa::Router.instance_variable_get(:@routes).inspect
   end
+
+  # Building urls
+  def test_09
+    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('/', Alfa::Router.href(:app=>:frontend, :controller=>:main, :action=>:index))
+    assert_equal('/', Alfa::Router.href(:app=>:frontend))
+    assert_equal('/hello', Alfa::Router.href(:app=>:frontend, :controller=>:main, :action=>:hello))
+    assert_equal('/hello', Alfa::Router.href(:app=>:frontend, :action=>:hello))
+    assert_equal('/hello/babuin', Alfa::Router.href(:app=>:frontend, :controller=>:hello, :action=>:babuin))
+    assert_equal('/hello/babuin/11', Alfa::Router.href(:app=>:frontend, :controller=>:hello, :action=>:babuin, :id=>11))
+    assert_equal('/admin/', Alfa::Router.href(:app=>:backend, :controller=>:main, :action=>:index))
+    assert_equal('/admin/', Alfa::Router.href(:app=>:backend))
+    assert_equal('/admin/', Alfa::Router.href(:app=>:backend, :controller=>:main))
+    assert_equal('/admin/babuin', Alfa::Router.href(:app=>:backend, :controller=>:babuin, :action=>:index))
+    assert_equal('/admin/babuin', Alfa::Router.href(:app=>:backend, :controller=>:babuin))
+
+    # Build urls with GET params
+    assert_equal('/?foo=bar', Alfa::Router.href(:app=>:frontend, :controller=>:main, :action=>:index, :params=>{:foo=>:bar}))
+    assert_equal('/?staki=gKyE', Alfa::Router.href(:app=>:frontend, :params=>{:staki=>'gKyE'}))
+    assert_equal('/?company=AT%26T', Alfa::Router.href(:app=>:frontend, :params=>{:company=>'AT&T'}))
+  end
+
 end