alfa 0.0.4.pre → 0.0.5.pre

data/dummy/project/apps/frontend/layouts/index.tpl.source

@@ -0,0 +1,5 @@
+{% extends 'base.tpl' %}
+
+{% block title %}#{PROJECT_NAME}{% endblock %}
+
+{% block body %}{{ body|raw }}{% endblock %}

data/dummy/project/apps/frontend/routes.rb

@@ -0,0 +1,11 @@
+Project::WebApplication.routes.draw do
+
+  route '/', :controller => :default, :action => :index, :layout => :index
+  #route '/:action', :controller => :default, :layout => :internal
+  #route '/:controller/:action', :layout => :internal
+  #route '/:controller/:action/:id', :layout => :internal
+
+  route 404, controller: :system, action: :page_404
+  route 500, controller: :system, action: :page_500
+
+end

data/dummy/project/apps/frontend/templates/default/index.tpl

@@ -0,0 +1 @@
+apps/frontend/default#index

data/dummy/project/config/cli_application.rb

@@ -0,0 +1,14 @@
+require 'alfa/cli_application'
+require File.expand_path('../env', __FILE__)
+require File.expand_path('../db', __FILE__)
+require File.expand_path('../groups', __FILE__)
+
+module Project
+  class CliApplication < Alfa::CliApplication
+    instance_eval(File.read(File.expand_path('../config.rb', __FILE__)), File.expand_path('../config.rb', __FILE__))
+    config[:run_mode] = :cli # :cli for command-line application
+    config[:log][:file] = File.join(PROJECT_ROOT, 'log/cli.log')
+  end
+
+  CliApplication.init!
+end

data/dummy/project/config/config.rb

@@ -0,0 +1,11 @@
+# Eval in actual application's context (CliApplication, WebApplication or other)
+
+config[:project_root] = PROJECT_ROOT
+config[:document_root] = DOCUMENT_ROOT
+config[:db][:main] = {
+    :instance => DB::Main,
+    :path => File.join(PROJECT_ROOT, 'db/main'), # require both instance and path
+    :maintain => true,
+}
+config[:groups] = Project::GROUPS
+config[:templates_priority] = [:haml, :tpl]

data/dummy/project/config/db.rb

@@ -0,0 +1,11 @@
+require 'alfa/database'
+require 'yaml'
+
+# Main database for application private use
+module DB
+  Main = Sequel.connect(YAML.load(File.open(File.expand_path('../passwords/db-main.yml', __FILE__))).symbolize_keys[:dsn], :encoding=>'utf8')
+end
+
+Dir[File.join(PROJECT_ROOT, 'db/main/models/*.rb')].each do |f|
+  require f
+end

data/dummy/project/config/env.rb

@@ -0,0 +1,6 @@
+# Setting up environment variables
+
+PROJECT_ROOT = File.expand_path('../..', __FILE__)
+DOCUMENT_ROOT = File.expand_path('../../public', __FILE__)
+Alfa::TFile.project_root = PROJECT_ROOT
+Alfa::TFile.document_root = DOCUMENT_ROOT

data/dummy/project/config/groups.rb

@@ -0,0 +1,17 @@
+module Project
+  # Here is hash of groups with list of grants in each.
+  # Guest group is required and may be empty, all other groups are optional.
+  GROUPS = {
+      # Add custom groups here. Example:
+      # :some_group => [:send_mails, :create_users, :moderate_forum],
+      # Note that :some_group=>[:some_grant] and :other_group=>[:some_grant] points to same :some_grant
+
+      # :admin_index - predefined (system required) grant for browse admin app
+      :admin => [:admin_index],
+
+      # Public group is associated with all users include non-logged in.
+      # This group is empty by default, but you can put some grants in it.
+      # For example :public => [:foo] means that all users respond to .grant?(:foo) as true.
+      :public => [],
+  }
+end

data/dummy/project/config/passwords/db.sample.yml

@@ -0,0 +1,8 @@
+---
+# dns format ([...] can be omitted):
+# adapter://user:[password]@host[:port]/database
+dsn: "mysql2://root:123456@localhost:3306/site"
+host: "localhost"
+user: "root"
+password: "123456"
+dbname: "site"

data/dummy/project/config/routes.rb

@@ -0,0 +1,4 @@
+Project::WebApplication.routes.draw do
+  mount '/admin/', :admin
+  mount '/', :frontend
+end

data/dummy/project/config/setup_load_paths.rb

@@ -0,0 +1,14 @@
+# This file required by Phusion Passenger
+
+if ENV['MY_RUBY_HOME'] && ENV['MY_RUBY_HOME'].include?('rvm')
+  begin
+    require 'rvm'
+    RVM.use_from_path! File.dirname(File.dirname(__FILE__))
+  rescue LoadError
+    raise "RVM gem is currently unavailable."
+  end
+end
+
+# If you're not using Bundler at all, remove lines bellow
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', File.dirname(__FILE__))
+require 'bundler/setup'

data/dummy/project/config/web_application.rb

@@ -0,0 +1,15 @@
+require 'alfa/web_application'
+require File.expand_path('../env', __FILE__)
+require File.expand_path('../db', __FILE__)
+require File.expand_path('../groups', __FILE__)
+
+module Project
+  class WebApplication < Alfa::WebApplication
+    instance_eval(File.read(File.expand_path('../config.rb', __FILE__)), File.expand_path('../config.rb', __FILE__))
+    config[:run_mode] = :development # :development or :production or :test
+    config[:log][:file] = File.join(PROJECT_ROOT, 'log/web.log')
+    config[:serve_static] = true
+  end
+
+  WebApplication.init!
+end

data/dummy/project/config.ru

@@ -0,0 +1,3 @@
+require File.expand_path('../config/web_application', __FILE__)
+
+Project::WebApplication.rackup self

data/dummy/project/db/main/schema.yml

@@ -0,0 +1,3 @@
+---
+engine: mysql
+encoding: utf8

data/dummy/project/public/robots.txt

@@ -0,0 +1 @@
+User-Agent: *

data/lib/alfa/application.rb

@@ -8,7 +8,7 @@ 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)
+  # 1st using - in Rake tasks (see self.load_tasks)
   VARS = {}
 
   class Application
@@ -19,8 +19,9 @@ module Alfa
 
     @config = Alfa::Config.new
 
-    def self.config(kwargs={})
-      @config.merge! kwargs
+    def self.config(kwargs = nil)
+      @config.merge!(kwargs) if kwargs
+      @config
     end
 
 
@@ -29,7 +30,7 @@ module Alfa
       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}"
+        str = "Application (pid=#{$$}) started in #{@config[:run_mode]} mode at #{DateTime.now}"
         @logger.info "#{'='*str.length}\n#{str}"
         @logger.info "  PROJECT_ROOT: #{@config[:project_root]}"
         @logger.info "  DOCUMENT_ROOT: #{@config[:document_root]}\n"
@@ -50,7 +51,7 @@ module Alfa
 
 
     def self.verify_config
-      raise Exceptions::E001 unless @config[:project_root]
+      raise Exceptions::E001.new('config[:project_root] should be defined') unless @config[:project_root]
     end
   end
 end

data/lib/alfa/commands/new.rb

@@ -1,4 +1,49 @@
-project_name = $*[1]
-target_dir = File.join(Dir.pwd, project_name)
-raise "file or directory #{project_name} already exists" if File.exists?(target_dir)
-Dir.mkdir project_name
+require File.expand_path('../../../../version', __FILE__)
+require 'fileutils'
+require 'alfa/support'
+
+PROJECT_NAME = $*[1]
+
+sr = {
+  '#{ALFA_VERSION}' => ALFA_VERSION,
+  '#{PROJECT_NAME}' => PROJECT_NAME,
+}
+
+target_dir = File.join(Dir.pwd, PROJECT_NAME)
+raise "file or directory #{PROJECT_NAME} already exists" if File.exists?(target_dir)
+Dir.mkdir PROJECT_NAME
+
+puts "Created new project in #{PROJECT_NAME}"
+
+begin
+  print "Copy dummy project... "
+  source_base_len = File.expand_path('../../../../dummy/project', __FILE__).length + 1
+  Dir[File.expand_path('../../../../dummy/project/**/{*,.[^.]*}', __FILE__)].each do |path|
+    relpath = path[source_base_len..-1]
+    target = File.join(target_dir, relpath)
+    if File.directory?(path)
+      FileUtils.mkdir_p target, :mode => 0755
+    else
+      if File.extname(relpath) == '.source'
+        File.open(target.chomp('.source'), File::WRONLY | File::CREAT) do |f|
+          f.write(File.read(path).strtr(sr))
+        end
+      else
+        FileUtils.cp(path, target)
+      end
+    end
+  end
+  print "done"
+ensure
+  puts ""
+end
+
+begin
+  print "Bundle install... "
+  FileUtils.cd PROJECT_NAME
+  `bundle install`
+  print "done"
+ensure
+  FileUtils.cd '..'
+  puts ""
+end

data/lib/alfa/controller.rb

@@ -1,7 +1,124 @@
+require 'alfa/support'
+require 'alfa/exceptions'
+
 module Alfa
   class Controller
+    attr_accessor :application, :request, :config, :app_sym, :c_sym
+
     def _instance_variables_hash
-      Hash[instance_variables.map { |name| [name.to_s[1..-1].to_sym, instance_variable_get(name)] } ]
+      Hash[instance_variables.map { |name| [name.to_sym, instance_variable_get(name)] } ]
+    end
+
+    def _clear_instance_variables
+      instance_variables.each {|name| remove_instance_variable(name)}
+    end
+
+    def href(*o)
+      kwargs = _extract_href_params(*o)
+      @application.routes.href(kwargs)
+    end
+
+    alias :href_to :href
+
+    def _extract_href_params(*o)
+      args, kwargs = Support.args_kwargs(*o)
+      if args.any?
+        if args.first.is_a?(Symbol)
+          kwargs[:action] = args.first
+        else
+          kwargs.merge! _string_to_aca(args.first.to_s)
+        end
+      end
+      kwargs = {:app=>@app_sym}.merge kwargs
+      kwargs = {:controller=>@c_sym}.merge kwargs if kwargs[:action]
+      kwargs
+    end
+
+    # Convert string to App-Controller-Action hash
+    # 'app*controller#action'
+    def _string_to_aca(str)
+      res = {}
+      s1 = str.split('@')
+      raise Exceptions::E004.new("E004: Bad href argument #{str}: it should contain at most one @ symbol") if s1.length > 2
+      res[:app] = s1.last.to_sym if s1.length > 1
+      s2 = s1.first.split('#')
+      raise Exceptions::E004.new("E004: Bad href argument #{str}: it should contain at most one # symbol") if s2.length > 2
+      res[:controller] = s2.first.to_sym if s2.length > 1
+      res[:action] = s2.last.to_sym if s2.length > 0
+      res
+    end
+
+
+    def session
+      @request.session
+    end
+
+    # Return current user
+    def user
+      @user ||= (
+        if @request.session[:user_id] && (u = @application.config[:db][:main][:instance][:users].first(id: @request.session[:user_id]))
+          User.new(u)
+        else
+          GuestUser
+        end
+      )
+    end
+
+
+    def grant?(grant)
+      user.grant?(grant)
+    end
+
+
+    [300, 301, 302, 303].each do |code|
+      define_method ("redirect_#{code}".to_sym) do |url|
+        @application.redirect(url, code)
+      end
+    end
+
+    alias :redirect :redirect_302
+
+
+    def try_login(username, password)
+      u = @application.config[:db][:main][:instance][:users].first(login: username)
+      raise "No such login: #{username}" unless u
+      if u[:passhash] == Digest::MD5.hexdigest("#{u[:salt]}#{password}")
+        # success
+        session[:user_id] = u[:id]
+        return true
+      else
+        # fail
+        session[:user_id] = nil
+        raise 'login fail'
+        return false
+      end
+    end
+
+
+    def try_register(username, password)
+      @config[:db][:main][:instance].transaction do
+        unless @config[:db][:main][:instance][:users].first(:login=>username)
+          @logger.portion do |l|
+            salt = SecureRandom.hex(5)
+            passhash = Digest::MD5.hexdigest("#{salt}#{password}")
+            @config[:db][:main][:instance][:users].insert(:login=>username, :salt=>salt, :passhash=>passhash)
+            l.info("create new user login=#{username}, password=#{password}, salt=#{salt}, passhash=#{passhash}")
+          end
+          return true, "Registration done"
+        end
+        return false, "User with login #{username} already exists"
+      end
+    end
+
+
+    def try_logout
+      session[:user_id] = nil
+      @user = GuestUser
+    end
+
+    # Store flash message to session
+    def flash(message)
+
     end
   end
 end

data/lib/alfa/database/mysql.rb

@@ -27,7 +27,7 @@ module Alfa
         raise "Unacceptible engine in #{path}/schema.yml, expected to be mysql of mysql2" unless ['mysql', 'mysql2'].include? data[:engine]
         Dir[File.join(path, 'models/*.rb')].each do |file|
           require file
-          Kernel::const_get(Alfa::Support.capitalize_name(File.basename(file, '.rb'))).register_database self
+          Kernel::const_get(Alfa::Support.camelcase_name(File.basename(file, '.rb'))).register_database self
         end
 
       end

data/lib/alfa/exceptions.rb

@@ -3,10 +3,23 @@ module Alfa
     # Route not found
     class Route404 < StandardError; end
 
+    class HttpRedirect < StandardError
+      attr_reader :url, :code
+      def initialize(url, code)
+        @url, @code = url, code
+      end
+    end
+
     # Application's config.project_root required
     class E001 < StandardError; end
 
     # WebApplication's config.document_root required
     class E002 < StandardError; end
+
+    # Href can't be build
+    class E003 < StandardError; end
+
+    # Bad str for href format
+    class E004 < StandardError; end
   end
 end

data/lib/alfa/logger.rb

@@ -12,6 +12,9 @@ module Alfa
     def info(*args)
     end
 
+    def debug(*args)
+    end
+
     def <<(*args)
     end
   end

data/lib/alfa/router.rb

@@ -1,3 +1,6 @@
+require 'alfa/exceptions'
+require 'rack/utils'
+
 module Alfa
   class Router
 
@@ -165,5 +168,27 @@ module Alfa
       raise Alfa::Exceptions::Route404
     end
 
+
+    def self.href(kwargs={})
+      params = kwargs[:params] || {}
+      kwargs.delete!(:params)
+      @routes.each do |route|
+        if route[:context].is_a?(Hash) # container
+          if route[:context][:app][:app] == kwargs[:app]
+            route[:routes].each do |r|
+              r[:placeholders] = r[:rule].scan(/:([a-z_][a-z0-9_]*)/).map{|m| m[0].to_sym}.sort unless r[:placeholders]
+              if (r[:placeholders] - kwargs.keys).empty? &&
+                  (kwargs.keys & r[:options].keys).all?{|key| kwargs[key] == r[:options][key]} &&
+                  (kwargs.keys - [:app] - r[:placeholders] - r[:options].keys).empty?
+                result = File.join(route[:context][:app][:path], r[:rule].strtr(kwargs.map{|key, value| [":#{key}", value.to_s]}))
+                result += "?#{::Rack::Utils.build_query(params)}" if params.any?
+                return result
+              end
+            end
+          end
+        end
+      end
+      raise Exceptions::E003.new("Can't build url by params #{kwargs}")
+    end
   end
 end

data/lib/alfa/ruty.rb

@@ -0,0 +1,10 @@
+require 'ruty'
+require 'ruty/bugfix'
+require 'ruty/upgrade'
+require 'ruty/tags/resources'
+require 'ruty/tags/href'
+
+module Ruty
+  # Global variable, bad code style
+  AUX_VARS = {}
+end

data/lib/alfa/support.rb

@@ -31,13 +31,17 @@ module Alfa
   module Support
     extend self
 
-    def capitalize_name(arg)
+    def camelcase_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, {}
+    def underscore_name(arg)
+      arg.to_s.split('/').last.scan(/[A-Z][a-z]*|[a-z]+/).map(&:downcase).join('_')
+    end
+
+    def args_kwargs(*args)
+      return args[0..-2], args.last if args.last.is_a?(Hash)
+      return args, {}
     end
   end
 
@@ -97,4 +101,35 @@ class Hash
     end
     self
   end
+
+
+  def delete!(*keys)
+    keys.each{|key| self.delete(key)}
+    self
+  end
+
+
+  def except(*keys)
+    self.dup.delete!(*keys)
+  end
+end
+
+
+class String
+  # PHP's two argument version of strtr
+  def strtr(replace_pairs)
+    keys = replace_pairs.map {|a, b| a }
+    values = replace_pairs.map {|a, b| b }
+    self.gsub(
+        /(#{keys.map{|a| Regexp.quote(a) }.join( ')|(' )})/
+    ) { |match| values[keys.index(match)] }
+  end
+
+  def strtr!(replace_pairs)
+    keys = replace_pairs.map {|a, b| a }
+    values = replace_pairs.map {|a, b| b }
+    self.gsub!(
+        /(#{keys.map{|a| Regexp.quote(a) }.join( ')|(' )})/
+    ) { |match| values[keys.index(match)] }
+  end
 end

data/lib/alfa/template-inheritance.rb

@@ -0,0 +1,3 @@
+require 'template-inheritance/alfa_bugfix'
+require 'template-inheritance'
+require 'template-inheritance/alfa_helpers'

data/lib/alfa/user.rb

@@ -0,0 +1,63 @@
+module Alfa
+  class << self
+    attr_accessor :GROUPS
+  end
+
+  class GuestUser
+    def self.grants
+      @grants ||= Alfa.GROUPS[:public]
+    end
+
+    def self.grant?(name)
+      grants.include?(name.to_sym)
+    end
+
+    def self.groups
+      []
+    end
+
+    def self.group?(name)
+      groups.include?(name.to_sym)
+    end
+
+    def self.logged?
+      false
+    end
+
+    def [](key)
+      nil
+    end
+  end
+
+  class User
+    def initialize(properties)
+      @properties = properties
+    end
+
+    def grants
+      @groups_p ||= groups + [:public]
+      @groups_p.map{|g| Alfa.GROUPS[g] || []}.flatten
+    end
+
+    def grant?(name)
+      grants.include?(name.to_sym)
+    end
+
+    # @return Array
+    def groups
+      @groups ||= @properties[:groups].to_s.split(',').map{|s| s.strip.to_sym}
+    end
+
+    def group?(name)
+      groups.include?(name.to_sym)
+    end
+
+    def logged?
+      true
+    end
+
+    def [](key)
+      @properties[key]
+    end
+  end
+end