alfa 0.0.1.pre → 0.0.2.pre

data/lib/alfa/database/mysql.rb

@@ -1,55 +1,107 @@
 require 'alfa/support'
 require 'mysql2'
+require 'alfa/models/mysql'
+require 'alfa/query_logger'
+require 'yaml'
 
 module Alfa
   module Database
     class MySQL
       include Alfa::ClassInheritance
-      inheritable_attributes :host, :port, :user, :password, :dbname, :client
+      inheritable_attributes :host, :port, :user, :password, :dbname, :client, :config, :schema_path, :encondig
       @host = nil
       @port = 3306
       @user = nil
       @password = nil
       @dbname = nil
       @client = nil
+      @config = nil
+      @schema_path = nil
+      @encoding = nil
+
+      def self.load_schema path
+        @schema_path = path
+        data = YAML::load File.open(File.join(path, 'schema.yml'))
+        data.symbolize_keys!
+        @encoding = data[:encoding] if data[:encoding]
+        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
+        end
+
+      end
+
+      def self.load_config file
+        @config = file
+        data = YAML::load File.open(file)
+        data.symbolize_keys!
+        @host = data[:host] if data[:host]
+        @port = data[:port] if data[:port]
+        @user = data[:user] if data[:user]
+        @password = data[:password] if data[:password]
+        @dbname = data[:dbname] if data[:dbname]
+      end
 
       def self.check_params
         raise ":host must be defined for #{self.to_s}" unless @host
         raise ":user must be defined for #{self.to_s}" unless @user
         raise ":password must be defined for #{self.to_s}" unless @password
         raise ":dbname must be defined for #{self.to_s}" unless @dbname
+        raise ":encoding must be defined for #{self.to_s}" unless @encoding
       end
 
       def self.query query
+        self.check_client
         begin
-          self.client.query(query)
+          Alfa::QueryLogger.log query, self do
+            @client.query(query)
+          end
         rescue Mysql2::Error => e
           raise "#{e.message} (query: \"#{query}\", error number: #{e.error_number}, sql state: #{e.sql_state})"
         end
       end
 
-      def self.client
+      def self.check_client
         unless @client
           self.check_params
           @client = Mysql2::Client.new(:host=>@host, :username=>@user)
           @client.query_options.merge!(:symbolize_keys => true, :as => :hash, :database_timezone => :utc, :application_timezone => :utc)
-          @client.query "SET NAMES utf8"
-          @client.query "USE #{@dbname}"
+          Alfa::QueryLogger.log "SET NAMES utf8", self do
+            @client.query "SET NAMES " + @encoding
+          end
+          Alfa::QueryLogger.log "USE `#@dbname`", self do
+            @client.query "USE `#@dbname`"
+          end
         end
-        @client
       end
 
       def self.transaction &block
+        self.check_client
         begin
           self.query "START TRANSACTION"
           yield
-        rescue
+        rescue StandardError => e
           self.query "ROLLBACK"
+          raise e
         else
           self.query "COMMIT"
         end
       end
 
+      def self.escape arg
+        case arg.class
+          when Numeric
+            arg.to_s
+          when Array
+            arg.map {|a|
+              self.escape(a).to_s
+            }.join(',')
+          else
+            client.escape arg.to_s
+        end
+      end
+
     end
   end
-end
+end

data/lib/alfa/database.rb

@@ -1 +1,2 @@
-require 'alfa/database/mysql'
+#require 'alfa/database/mysql'
+require 'sequel'

data/lib/alfa/logger.rb

@@ -0,0 +1,38 @@
+require 'logger'
+
+module Alfa
+  class Logger < ::Logger
+
+    def initialize(logdev, shift_age = 0, shift_size = 1048576)
+      super
+      @formatter = Formatter.new
+    end
+
+    def portion(&block)
+      io = VirtualIO.new
+      l = ::Logger.new(io)
+      l.formatter = @formatter
+      yield(l)
+      self << io.join
+      l = nil
+      io = nil
+    end
+
+    private
+
+    class VirtualIO < ::Array
+      def write(message)
+        self.push message
+      end
+
+      def close
+      end
+    end
+
+    class Formatter < ::Logger::Formatter
+      def call(severity, time, progname, msg)
+        msg2str("#{msg}\n")
+      end
+    end
+  end
+end

data/lib/alfa/models/base.rb

@@ -4,4 +4,4 @@ module Alfa
 
     end
   end
-end
+end

data/lib/alfa/models/base_sql.rb

@@ -6,4 +6,4 @@ module Alfa
 
     end
   end
-end
+end

data/lib/alfa/models/dummy.rb

@@ -4,4 +4,4 @@ module Alfa
 
     end
   end
-end
+end

data/lib/alfa/models/mysql.rb

@@ -1,5 +1,4 @@
 require 'alfa/support'
-require 'alfa/database/mysql'
 require 'alfa/models/base_sql'
 
 module Alfa
@@ -7,46 +6,57 @@ module Alfa
     class MySQL < Alfa::Models::BaseSQL
       include Alfa::ClassInheritance
       inheritable_attributes :connection, :table
+
       @connection = nil
       @table = nil
       @pk = :id
 
-      def self.register_database database
-        raise 'Expected database to be instance of Alfa::Database::MySQL' unless database.ancestors.include? Alfa::Database::MySQL
-        @connection = database
-      end
+      class << self
 
-      #@return Array || nil
-      def self.all
-        @connection.query("SELECT * FROM `#{self.table}`")
-      end
+        def register_database database
+          raise 'Expected database to be instance of Alfa::Database::MySQL' unless database.ancestors.include? Alfa::Database::MySQL
+          @connection = database
+        end
 
-      def self.find filter = {}
+        #@return Array || nil
+        def all
+          @connection.query("SELECT * FROM `#{self.table}`")
+        end
 
-      end
+        def find filter = {}
 
-      def self.find_first filter = {}
-      end
+        end
 
-      def self.count filter = {}
-      end
+        def find_first filter = {}
+        end
 
-      def self.exists? pk
-      end
+        def count filter = {}
+        end
 
-      def self.create data = {}
-      end
+        def exists? pk
+        end
 
-      def self.delete pk
-      end
+        def create data = {}
+          #data.symbolize_keys!
+          @connection.query("INSERT INTO `#{self.table}` SET #{self.prepare_set_string(data)}")
+        end
 
-      def self.update data = {}
-      end
+        def delete pk
+        end
+
+        def update data = {}
+        end
+
+        def table
+          @table.to_s
+        end
+
+        def prepare_set_string data = {}
+          data.map{|field, value| "`#{@connection.escape(field)}`='#{@connection.escape(value)}'"}.join(', ')
+        end
 
-      def self.table
-        @table.to_s
       end
 
     end
   end
-end
+end

data/lib/alfa/models.rb

@@ -1,2 +1,2 @@
 require 'alfa/models/mysql'
-require 'alfa/models/dummy'
+require 'alfa/models/dummy'

data/lib/alfa/query_logger.rb

@@ -0,0 +1,29 @@
+module Alfa
+  class QueryLogger
+    @logs = []
+    @num = 0
+    class << self
+      def log query, instance = nil, &block
+        @num += 1
+        if block_given?
+          log = {:num => @num, :query => query, :instance => instance, :status => :started, :error => nil, :logger_hash => self.hash}
+          @logs << log
+          begin
+            result = yield
+          rescue StandardError => e
+            log[:status] = :fail
+            log[:error] = e.message
+            raise e
+          end
+          log[:status] = :done
+          return result
+        else
+          @logs << {:num => @num, :query => query, :instance => instance, :status => :flat, :logger_hash => self.hash}
+        end
+      end
+      def logs
+        @logs
+      end
+    end
+  end
+end

data/lib/alfa/router.rb

@@ -0,0 +1,155 @@
+module Alfa
+  class Router
+
+    # initialize class variables
+    @routes = []
+    @cursor = @routes
+    @cursors_stack = []
+    @mounts = []
+    @apps_dir = nil
+
+    def self.call &block
+    end
+
+    def self.set_apps_dir dir
+      @apps_dir = dir
+    end
+
+
+    def self.context options = {}, &block
+      new_routes_container = []
+      new_cursor = new_routes_container
+      if options.has_key?(:app)
+        app = @mounts.find {|item| item[:app] == options[:app]}
+        options[:app] = app
+      end
+      @cursor << {:context => options, :routes => new_routes_container}
+      @cursors_stack.push @cursor
+      @cursor = new_cursor
+      yield
+      @cursor = @cursors_stack.pop
+    end
+
+
+    def self.reset
+      @routes = []
+    end
+
+    # Set routes
+    # Example:
+    #   WebApplication.Router.draw do
+    #     mount '/admin/', :admin
+    #     route '/rss.xml', 'frontend/feeds#rss'
+    #     route '/atom.xml', 'frontend/feeds#atom'
+    #     mount '/', :frontend
+    #     subdomain :forum do
+    #       mount '/', :forum
+    #     end
+    #   end
+    def self.draw &block
+      route '/~assets/:path**', :type => :asset if @cursors_stack.empty?
+      class_eval &block
+    end
+
+    # Set rules in subdomain context
+    def self.subdomain &block
+    end
+
+    # Mount application to path
+    # Examples:
+    # all requests to url site.com/admin/ and nested (site.com/admin/*) will be sent to application 'backend' (/apps/backend)
+    #   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 = {}
+      @mounts << {:path => path, :app => app, :options => options}
+      if @apps_dir
+        self.context :app => app do
+          require File.join(@apps_dir, app.to_s, 'routes')
+        end
+      end
+    end
+
+    # Sets route rule
+    def self.route rule, options = {}
+      @cursor << {:rule => rule, :options => options}
+      #puts "set rule '#{rule}', routes = #{@routes}"
+    end
+
+    # @todo write tests for this method
+    def self.app_match? path, url
+      path_segments = path.split('/').reject(&:empty?)
+      url_segments = url.split('/').reject(&:empty?)
+      path_segments.zip(url_segments).reduce(true) {|res, pare| res && pare[0] == pare[1]}
+    end
+
+
+    def self.route_match? rule, url
+      #bputs rule
+      if rule.is_a? String
+        rule_trail_slash = rule[-1] == '/'
+        url_trail_slash = url[-1] == '/'
+        rule_segments = rule.split('/').reject(&:empty?) # @todo optimize (one split per server session instead of split per method call)
+        url_segments = url.split('/').reject(&:empty?)   # @todo optimize (one split per server session instead of split per method call)
+        if rule_segments.first == '~assets' && url_segments.first == '~assets'
+          path = url_segments[1..-1].join('/')
+          if File.file?(File.expand_path('../../../assets/'+path, __FILE__))
+            return true, {path: path, type: :asset}
+          else
+            return false, {}
+          end
+        end
+        rule_segments += [nil]*(url_segments.size - rule_segments.size) if url_segments.size > rule_segments.size
+        pares = {}
+        skip_flag = false
+        fail_flag = false
+        rule_segments.zip(url_segments).each do |rule_segment, url_segment|
+          skip_flag = true if rule_segment == '**'
+          if rule_segment =~ /^:[a-z]+\w*$/i && url_segment =~ /^[a-z0-9_]+$/
+            pares[rule_segment[1..-1].to_sym] = url_segment
+          elsif (rule_segment == url_segment) || (rule_segment == '*' && url_segment =~ /^[a-z0-9_]+$/) || (rule_segment == nil && skip_flag) || rule_segment == '**'
+          else
+            fail_flag = true
+            break
+          end
+        end
+        fail_flag = true if rule_trail_slash != url_trail_slash
+        return !fail_flag, pares
+      elsif rule.is_a? Regexp
+        match = rule.match url
+        if match
+          pares = Hash[match.names.map(&:to_sym).zip(match.captures)]
+          return true, pares
+        else
+          return false, {}
+        end
+      end
+    end
+
+    # @param string url
+    # @return route, params
+    # route is route that given in routes.rb
+    # params is detected params
+    def self.find_route url
+      @routes.each do |route|
+        if route[:context].is_a? Hash # container
+          if self.app_match?(route[:context][:app][:path], url)
+            url = url[(route[:context][:app][:path].length-1)..-1]
+            route[:routes].each do |r|
+              is_success, params = self.route_match?(r[:rule], url)
+              r[:options][:app] = route[:context][:app][:app]
+              return r, params if is_success
+            end
+            raise Alfa::RouteException404
+          end
+          # else - ???
+        else
+          is_success, params = self.route_match?(route[:rule], url)
+          return route, params if is_success
+        end
+      end
+      raise Alfa::RouteException404
+    end
+
+  end
+end

data/lib/alfa/support.rb

@@ -1,6 +1,6 @@
 module Alfa
 
-  # thanks to John
+  # Thanks to John
   # http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/
   module ClassInheritance
     def self.included(base)
@@ -34,4 +34,60 @@ module Alfa
     end
   end
 
-end
+end
+
+
+class Module
+  def load_in_module_context file
+    module_eval file, file
+  end
+
+  def load_in_class_context file
+    class_eval file, file
+  end
+end
+
+
+class BasicObject
+  def load_in_instance_context file
+    instance_eval file, file
+  end
+end
+
+# Borrowed from active_support/core_ext/hash/keys.rb
+class Hash
+  # Return a new hash with all keys converted to strings.
+  #
+  #   { :name => 'Rob', :years => '28' }.stringify_keys
+  #   #=> { "name" => "Rob", "years" => "28" }
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   { 'name' => 'Rob', 'years' => '28' }.symbolize_keys
+  #   #=> { :name => "Rob", :years => "28" }
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+end

data/lib/alfa/tfile.rb

@@ -0,0 +1,97 @@
+require 'alfa/support'
+
+module Alfa
+  class TFile
+
+    class << self
+      attr_reader :project_root, :document_root
+      def project_root=(arg)
+        @project_root = File.expand_path(arg) + '/'
+        @document_root = @project_root + 'public/'
+      end
+      def document_root=(arg)
+        @document_root = File.expand_path(arg) + '/'
+      end
+      def allowed_options
+        @allowed_options ||= %w(absfile projfile url).map(&:to_sym)
+      end
+      def inherited(subclass)
+        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
+
+    def initialize options={}
+      (options.keys - self.class.allowed_options).each do |opt|
+        raise "unknown option #{opt}, expected one of: #{self.class.allowed_options.join(', ')}"
+      end
+      raise "only one of #{self.class.allowed_options.join(', ')} allowed" if options.length > 1
+      if options.has_key?(:absfile)
+        self.absfile= options[:absfile]
+      elsif options.has_key? :projfile
+        self.projfile= options[:projfile]
+      end
+    end
+
+    def absfile= arg
+      @absfile = arg
+      @basename = File.basename(arg)
+      @dirname = File.dirname(arg) + '/'
+    end
+
+    def projfile= arg
+      raise "Please set up #{self.class}.project_root before call #{__method__}" unless self.class.project_root
+      self.absfile= File.join(self.class.project_root, arg)
+    end
+
+    def basename= arg
+      @basename = arg
+      @absfile = File.join(@dirname, @basename)
+    end
+
+    def extname
+      File.extname(@basename)
+    end
+
+    def extname= arg
+      arg = '.' + arg unless arg =~ /^\./
+      self.basename= self.filename + arg
+    end
+
+    def filename
+      File.basename(@basename, File.extname(@basename))
+    end
+
+    def filename= arg
+      self.basename= arg + self.extname
+    end
+
+    def dirname= arg
+      @dirname = File.expand_path(arg) + '/'
+      @absfile = File.join(@dirname, @basename)
+    end
+
+    def url
+      if self.absfile[0, self.class.document_root.length] == self.class.document_root
+        self.absfile[(self.class.document_root.length-1)..-1]
+      end
+    end
+
+    def url= arg
+      raise "Please set up #{self.class}.document_root before call #{__method__}" unless self.class.document_root
+      self.absfile= File.join(self.class.document_root, arg)
+    end
+
+    def to_str
+      self.absfile
+    end
+
+    def to_s
+      self.to_str
+    end
+
+  end
+end