alfa 0.0.5.pre → 0.0.6.pre

data/lib/alfa/tasks/db.rake

@@ -0,0 +1,169 @@
+require 'sequel/extensions/migration'
+require 'alfa/logger'
+
+# All maintainable databases
+def dbs
+  Alfa::VARS[:rakeapp_instance].instance_eval do
+    config[:db].select{|name, db| db[:maintain]}
+  end
+end
+
+namespace :db do
+  # Auxiliary task
+  # Check is database name given, if not given - exit with error message
+  task :require_db do
+    unless ENV['db']
+      puts "Please specify database such as: db=database"
+      puts "Known maintainable databases: " << dbs.map{|name, db| name}.join(', ')
+      exit
+    end
+    @db_name = ENV['db'].to_sym
+    @db = dbs[@db_name]
+    unless @db
+      puts "Unknown database \"#{ENV['db']}\". Known maintainable databases: " << dbs.map{|name, db| name}.join(', ')
+      exit
+    end
+  end
+
+  # Auxiliary task
+  # Set @db if database name given
+  task :optional_db do
+    @db = nil
+    @db_name = nil
+    if ENV['db']
+      @db_name = ENV['db'].to_sym
+      @db = dbs[@db_name]
+      unless @db
+        puts "Unknown database. Known maintainable databases: " << dbs.map{|name, db| name}.join(', ')
+        exit
+      end
+    end
+  end
+
+  # Auxiliary task
+  # Set logger($stdout) for all databases
+  task :stdout_logger do
+    @stdout_logger ||= Alfa::Logger.new($stdout)
+    dbs.each_value do |db|
+      db[:instance].loggers << @stdout_logger
+    end
+  end
+
+  desc "Drop all tables in schema"
+  task :drop => [:require_db, :stdout_logger] do
+    @db[:instance].tables.each do |table|
+      @db[:instance].foreign_key_list(table).each do |key|
+        @db[:instance].alter_table table do
+          drop_foreign_key(key[:columns])
+        end
+      end
+    end
+    @db[:instance].drop_table(*@db[:instance].tables)
+  end
+
+  desc "Create dumb migration for certain database and puts them into PROJECT_ROOT/db/%database%/migration"
+  task :'new-migration' => [:require_db, :stdout_logger] do
+    unless @db[:path]
+      puts "Error: not specified path for database #{@db_name}"
+      exit
+    end
+    ts = Time.now.utc.strftime('%Y%m%d%H%M%S')
+    pattern = <<EOL
+# Migration #{ts}
+# Don't rename this file after implement migration
+
+Sequel.migration do
+  up do
+    # Put up migration code here
+    # Use Sequel migration syntax (http://sequel.jeremyevans.net/rdoc/files/doc/schema_modification_rdoc.html) or native SQL (run "SQL command")
+  end
+
+  down do
+    # Put down migration code here
+  end
+end
+EOL
+    filename = "#{ts}_m.rb"
+    migration_file = File.join(@db[:path], 'migrations', filename)
+    if File.exist?(migration_file)
+      puts "Error: file #{migration_file} already exists, exiting"
+      exit
+    end
+
+    File.open(migration_file, 'w') do |f|
+      f.write pattern
+      puts "Create migration #{migration_file}"
+    end
+  end
+
+  desc "Migrate database(s)"
+  task :migrate => [:optional_db, :stdout_logger] do
+    if @db
+      Sequel::Migrator.run(@db[:instance], File.join(@db[:path], 'migrations'))
+    else
+      dbs.each do |name, db|
+        Sequel::Migrator.run(db[:instance], File.join(db[:path], 'migrations'))
+      end
+    end
+  end
+
+  namespace :migrate do
+    desc "Migrate database 1 step up"
+    task :up => [:require_db, :stdout_logger] do
+      migrator = Sequel::TimestampMigrator.new(@db[:instance], File.join(@db[:path], 'migrations'))
+      if migrator.migration_tuples
+        m = migrator.migration_tuples.first
+        if m[2] == :up
+          target = m[1].split('_').first.to_i
+          Sequel::Migrator.run(@db[:instance], File.join(@db[:path], 'migrations'), :target=>target)
+        end
+      end
+    end
+
+    desc "Migrate database 1 step down"
+    task :down => [:require_db, :stdout_logger] do
+      migrator = Sequel::TimestampMigrator.new(@db[:instance], File.join(@db[:path], 'migrations'))
+      to_rollback = migrator.applied_migrations.last
+      if to_rollback
+        target = migrator.applied_migrations[0..-2].last # last but one applied migration
+        if target
+          target = target.split('_').first.to_i
+        else
+          target = 0
+        end
+        Sequel::Migrator.run(@db[:instance], File.join(@db[:path], 'migrations'), :target=>target)
+      else
+        puts "Nothing to rollback"
+      end
+    end
+  end
+
+  desc "Test databases connection parameters"
+  task :test do
+    errors = 0
+    dbs.each do |name, db|
+      begin
+        db[:instance].test_connection
+      rescue Sequel::DatabaseConnectionError => e
+        errors = errors + 1
+        puts e.message
+      end
+    end
+    if errors > 0
+      puts "Some DSN problems found. Check config/passwords/db-*.yml"
+    else
+      puts "All DSNs are ok!"
+    end
+  end
+
+  desc 'Seed chosen Database'
+  task :seed => [:optional_db, :stdout_logger] do
+    if @db
+      Kernel.load File.join(@db[:path], 'seed.rb')
+    else
+      dbs.each do |name, db|
+        Kernel.load File.join(db[:path], 'seed.rb')
+      end
+    end
+  end
+end

data/lib/alfa/tasks/generators.rake

@@ -0,0 +1,80 @@
+namespace :+ do
+
+  task :require_model => [:'db:require_db'] do
+    unless ENV['model']
+      puts "Please specify model in single form such as: model=images"
+      exit
+    end
+    @model_name = ENV['model'].to_sym
+    if File.exist?(File.join(PROJECT_ROOT, 'db', @db_name.to_s, 'models', "#{@model_name.to_s}.rb"))
+      puts "Model #{@model_name} for db #{@db_name} already exists"
+      exit
+    end
+  end
+
+  desc 'Create model'
+  task :model => [:'db:require_db', :require_model] do
+    model_filename = Alfa::Support.underscore_name(@model_name)
+    model_classname = Alfa::Support.camelcase_name(@model_name)
+    db_classname = Alfa::Support.camelcase_name(@db_name)
+    ts = Time.now.utc.strftime('%Y%m%d%H%M%S')
+    pattern = <<EOL
+# Migration #{ts} for model #{model_classname}
+# Don't rename this file after implement migration
+
+Sequel.migration do
+  up do
+    # Use Sequel migration syntax (http://sequel.jeremyevans.net/rdoc/files/doc/schema_modification_rdoc.html) or native SQL (run "SQL command")
+    create_table :#{model_filename}s do
+      primary_key :id
+      # ...
+      column :created_at, DateTime
+      column :updated_at, DateTime
+    end
+  end
+
+  down do
+    drop_table :#{model_filename}s
+  end
+end
+EOL
+    filename = "#{ts}_#{model_filename}s.rb"
+    migration_file = File.join(@db[:path], 'migrations', filename)
+    if File.exist?(migration_file)
+      puts "Error: file #{migration_file} already exists, exiting"
+      exit
+    end
+    File.open(migration_file, 'w') do |f|
+      f.write pattern
+      puts "Create migration #{migration_file}"
+    end
+
+    pattern = <<EOL
+class #{model_classname} < Sequel::Model(DB::#{db_classname}[:#{model_filename}s])
+  # Uncomment following plugins if necessary:
+  # plugin :timestamps, update_on_create: true
+  # plugin :prepared_statements
+  # plugin :serialization, %method%, %field%
+  # Read more about available plugins: http://sequel.jeremyevans.net/rdoc-plugins/classes/Sequel/Plugins.html
+
+  # Use associations:
+  # one_to_one :association_name, class: :OtherModel, key: :key_name
+  # one_to_many ...
+  # many_to_one ...
+  # many_to_many ...
+  # one_through_one ...
+  # Read more about association basics: http://sequel.jeremyevans.net/rdoc/files/doc/association_basics_rdoc.html
+end
+EOL
+    filename = "#{model_filename}.rb"
+    model_file = File.join(@db[:path], 'models', filename)
+    if File.exist?(model_file)
+      puts "Error: file #{model_file} already exists, exiting"
+      exit
+    end
+    File.open(model_file, 'w') do |f|
+      f.write pattern
+      puts "Create migration #{model_file}"
+    end
+  end
+end

data/lib/alfa/tasks.rb

@@ -1,2 +1,6 @@
 load 'alfa/tasks/assets.rake'
 load 'alfa/tasks/db.rake'
+load 'alfa/tasks/generators.rake'
+
+require 'rake/testtask'
+Rake::TestTask.new

data/lib/alfa/tfile.rb

@@ -56,7 +56,7 @@ module Alfa
     end
 
     def extname= arg
-      arg = '.' + arg unless arg =~ /^\./
+      arg = '.' + arg unless arg =~ /\A\./
       self.basename= self.filename + arg
     end
 

data/lib/alfa/user.rb

@@ -1,3 +1,6 @@
+require 'digest/md5'
+require 'securerandom'
+
 module Alfa
   class << self
     attr_accessor :GROUPS
@@ -27,16 +30,20 @@ module Alfa
     def [](key)
       nil
     end
+
+    def method_missing(*o)
+      nil
+    end
   end
 
+
   class User
-    def initialize(properties)
-      @properties = properties
+    def initialize(object)
+      @object = object
     end
 
     def grants
-      @groups_p ||= groups + [:public]
-      @groups_p.map{|g| Alfa.GROUPS[g] || []}.flatten
+      (groups + [:public]).map{|g| Alfa.GROUPS[g] || []}.flatten
     end
 
     def grant?(name)
@@ -45,7 +52,7 @@ module Alfa
 
     # @return Array
     def groups
-      @groups ||= @properties[:groups].to_s.split(',').map{|s| s.strip.to_sym}
+      @object.groups.map{|s| s.to_s.strip.to_sym}
     end
 
     def group?(name)
@@ -57,7 +64,35 @@ module Alfa
     end
 
     def [](key)
-      @properties[key]
+      @object[key]
+    end
+
+    def method_missing(*o)
+      @object.send(*o)
+    end
+
+    def self.method_missing(*o)
+      @object.class.send(*o)
+    end
+  end
+
+  # Prepend this module in User model in your Project
+  # Example:
+  #   class User < Sequel::Model(DB::Main[:users])
+  #     prepend Alfa::UserModule
+  #   end
+  module UserModule
+    def password=(p)
+      self.salt = SecureRandom.hex(5)
+      self.passhash = Digest::MD5.hexdigest("#{self.salt}#{p}")
+    end
+
+    def password_valid?(p)
+      self.passhash == Digest::MD5.hexdigest("#{self.salt}#{p}")
+    end
+
+    def groups=(g)
+      super(Array(g))
     end
   end
 end

data/lib/alfa/web_application.rb

@@ -5,16 +5,17 @@ require 'alfa/tfile'
 require 'alfa/controller'
 require 'alfa/router'
 require 'alfa/ruty'
-require 'alfa/user'
+require 'alfa/snippeter'
+require 'alfa/wrapper'
+require 'alfa/resourcer'
 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'
+require 'json'
 
 module Alfa
   class WebApplication < Alfa::Application
@@ -32,6 +33,7 @@ module Alfa
       end
     end
 
+    # noinspection RubyResolve
     def self.init!
       super
       Alfa::Router.reset
@@ -39,6 +41,9 @@ module Alfa
       load File.join(@config[:project_root], 'config/routes.rb')
       TemplateInheritance.logger = @logger
       Alfa.GROUPS = @config[:groups]
+      Alfa::Snippeter.config = @config
+      Alfa::Snippeter.mounts = Alfa::Router.mounts
+      Alfa::Snippeter.load
     end
 
     # main Rack routine
@@ -77,37 +82,60 @@ module Alfa
             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(app_sym, c_sym)
+            app_sym, c_sym, a_sym, l_sym = route_to_symbols(route, params)
+            controller = self.invoke_controller(app_sym, c_sym, route)
+            unless controller.class.instance_methods(false).include?(a_sym)
+              if route[:rule] =~ /\A\/:(controller|action)\/?\z/
+                route, params = self.routes.find_route(Rack::Utils.unescape(env['PATH_INFO']), exclude: [route[:rule]])
+                app_sym, c_sym, a_sym, l_sym = route_to_symbols(route, params)
+                controller = self.invoke_controller(app_sym, c_sym, route)
+                raise Exceptions::Route404 unless controller
+              end
+            end
             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 # 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'
+            controller.params = params
+            data = controller.__send__(a_sym)
+            case controller.class.get_content_type(a_sym)
+              when :json
+                headers['Content-Type'] = 'application/json; charset=utf-8'
+                body = JSON.generate(data, quirks_mode: true)
+              else
+                data = controller._instance_variables_hash
+                resourcer = Alfa::Resourcer.new
+                wrapper = Alfa::Wrapper.new(application: self, request: request, app_sym: app_sym, c_sym: c_sym, resourcer: resourcer, params: params, route: route)
+                Ruty::Tags::RequireStyle.clean_cache # cleanup
+                Ruty::Tags::RequireScript.clean_cache # cleanup
+                content = self.render_template(app_sym, c_sym, a_sym, controller, wrapper, data, &block)
+                if controller.class.get_render(a_sym) == :partial
+                  body = content
+                else
+                  body = self.render_layout(app_sym.to_s, l_sym.to_s, controller, wrapper, data.merge({:@body => content}))
+                end
+                headers['Content-Type'] = 'text/html; charset=utf-8'
+            end
           end
         rescue Alfa::Exceptions::Route404 => e
           response_code = 404
-          body = 'Url not found<br>urls map:<br>'
+          body = "Url not found (#{e.message}) <br>urls map:<br>"
           body += self.routes.instance_variable_get(:@routes).inspect
           l.info "404: Url not found (#{e.message})"
+        rescue Alfa::Exceptions::Route403 => e
+          response_code = 403
+          body = "Error 403: Forbidden (#{e.message})"
+          l.info "403: Forbidden"
         rescue Exceptions::HttpRedirect => e
           response_code = e.code
           headers['Location'] = e.url.to_s
-          body = ''
+          body = "You was redirected to #{e.url}"
         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")}"
+          body = "Error occured: #{CGI.escape_html(e.message)} at #{e.backtrace.first}<br>Full backtrace:<br>\n#{e.backtrace.join("<br>\n")}"
+          l.error "ERROR: #{e.message} at #{e.backtrace.first}"
         end
         if t_sym == :default
           #debug_info = '<hr>Queries:<br>' + @logger.logs.map { |log|
@@ -124,17 +152,44 @@ module Alfa
       return [response_code, headers, [body, @bputs.join('<br>')]]
     end
 
+
+    def self.route_to_symbols(route, params)
+      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
+      return app_sym, c_sym, a_sym, l_sym
+    end
+
     # router
     def self.routes
       @router ||= Alfa::Router
     end
 
 
+    def self.snippets
+      @snippeter ||= Alfa::Snippeter
+    end
+
+    # Evaluate snippet with given name
+    # @param Symbol name
+    # @param Alfa::Controller controller
+    # return String
+    def self.snippet(name, wrapper)
+      block = snippets[wrapper.app_sym][name]
+      raise "Not found snippet #{name} for app #{wrapper.app_sym}" unless block
+      wrapper.instance_eval(&block)
+      data = wrapper._instance_variables_hash
+      render_snippet(wrapper.app_sym, name, wrapper, data)
+    end
+
+
     def self.rackup(builder)
-      builder.use Rack::Session::Cookie
+      builder.use Rack::Lock
+      builder.use Rack::Session::Cookie, key: @config[:session][:key], secret: @config[:session][:secret]
       if @config[:serve_static]
         builder.run Rack::Cascade.new([
-          Rack::FileAlfa.new(@config[:document_root]),
+          Rack::FileAlfa.new(@config[:document_root], {'Cache-Control'=>'max-age=2592000'}),
           self,
         ])
       else
@@ -152,6 +207,7 @@ module Alfa
       raise Exceptions::HttpRedirect.new(url, code)
     end
 
+
   # private section
 
     def self.verify_config
@@ -162,30 +218,39 @@ module Alfa
       @config[:groups][:public] = [] unless @config[:groups][:public]
     end
 
-    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')
+    def self.invoke_controller(a_sym, c_sym, route)
+      f = File.join(@config[:project_root], 'apps', a_sym.to_s, 'controllers', c_sym.to_s + '.rb')
+      return nil unless File.exists?(f)
+      load f
       klass_name = Alfa::Support.camelcase_name(c_sym)+'Controller'
       klass = Kernel.const_get(klass_name) # weakref?
-      instance = klass.new
+      instance = klass.new(route: route)
       Object.module_eval{remove_const(klass_name)}
       return instance
     end
 
-    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)
+    def self.render_template(app_sym, c_sym, a_sym, controller, wrapper, data = {}, &block)
+      wrapper.resourcer.level = :action
+      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, wrapper: wrapper, &block)
+    end
+
+    def self.render_layout(app, layout, controller, wrapper, data = {})
+      wrapper.resourcer.level = :layout
+      render(file: File.join(@config[:project_root], 'apps', app, 'layouts', layout.to_s), controller: controller, wrapper: wrapper, data: data)
     end
 
-    def self.render_layout(app, layout, data = {})
-      render(file: File.join(@config[:project_root], 'apps', app, 'layouts', layout.to_s), data: data)
+    def self.render_snippet(app_sym, snip_sym, wrapper, data = {})
+      wrapper.resourcer.level = :snippet
+      render(file: File.join(@config[:project_root], 'apps', app_sym.to_s, 'templates/_snippets', snip_sym.to_s), wrapper: wrapper, data: data)
     end
 
-    def self.render(file: nil, controller: nil, data: {})
+    def self.render(file: nil, controller: nil, wrapper: 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)
+              template = self.haml_template(f, controller, wrapper)
               yield(controller, template) if block_given? # required only for thread isolation test
               return template.render data
             when :tpl
@@ -205,9 +270,9 @@ module Alfa
       @ruty_loader ||= Ruty::Loaders::Filesystem.new(:dirname => File.join(@config[:project_root], 'apps'))
     end
 
-    def self.haml_template(file, controller)
+    def self.haml_template(file, controller, wrapper)
       # @haml_templates[file.to_sym] ||= TemplateInheritance::Template.new(file)
-      scope = TemplateInheritance::RenderScope.new(controller)
+      scope = TemplateInheritance::RenderScope.new(controller, wrapper, wrapper.resourcer)
       TemplateInheritance::Template.new(file, scope)
     end