uzuuzu-core 0.0.4 → 0.0.5

data/lib/uzuuzu/helper/route.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+
+module UzuUzu
+  module Helper
+    module Route
+      module RouteClass
+        def url_for(*args)
+          app = UzuUzu.current
+          route_string = UzuUzu::Request.current.env['SCRIPT_NAME']
+          app.controllers.each do |controller|
+            re = Regexp.compile("^#{controller.name}::")
+            if re =~ self.name
+              path = self.name.gsub(re, '').gsub(/Controller$/, '').to_const_path
+              route_string << "/#{path}" unless path == 'index'
+              break
+            end
+          end
+          if args[-1].kind_of?(Hash)
+            query = query_string(args.pop)
+          end
+          args.each do |arg|
+            route_string << "/#{arg}"
+          end
+          
+          route_string << '/' if args.blank?
+          route_string << query unless query.blank?
+          route_string
+        end
+        alias :r :url_for
+        #
+        #
+        #
+        def query_string(query_options={})
+          query_string = []
+          query_options do |key, value|
+            query_string << "#{key}=#{value}"
+          end
+          return "" if query_string.blank?
+          "?#{query_string.join('&')}"
+        end
+      end
+      
+      def self.included(clazz)
+        clazz.extend RouteClass
+      end
+      
+      def url_for(*args)
+        route_string = @_route.clone
+        if args[-1].kind_of?(Hash)
+          query = query_string(args.pop)
+        end
+        args.each do |arg|
+          route_string << "/#{arg}"
+        end
+        route_string << '/' if args.blank?
+        route_string << query unless query.blank?
+        route_string
+      end
+      alias :r :url_for
+    end
+  end
+end

data/lib/uzuuzu/helper/uzuuzu_page.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+module UzuUzu
+  module Helper
+    #
+    #
+    #
+    module UzuUzuPage
+      #
+      #
+      #
+      def render_uzuuzu(resource, contents=nil)
+        @uzuuzu_resource = resource
+        @uzuuzu_header = render_contents(resource.header.contents)
+        @uzuuzu_footer = render_contents(resource.footer.contents)
+        @uzuuzu_left = render_contents(resource.left.contents)
+        @uzuuzu_right = render_contents(resource.right.contents)
+        @uzuuzu_contents = contents
+        @uzuuzu_contents ||= yield if block_given?
+        @uzuuzu_contents ||= render_contents(resource.page_body.contents) if resource.respond_to?(:page_body)
+        @uzuuzu_contents ||= ""
+        @uzuuzu_body = render_string(resource.layout.body, resource.layout.format)
+        if request.xhr?
+          return_string = @uzuuzu_body
+        else
+          return_string = render_file('./view/page.rhtml')
+        end
+        @uzuuzu_resource = @uzuuzu_header = @uzuuzu_footer = nil
+        @uzuuzu_left = @uzuuzu_right = @uzuuzu_contents = @uzuuzu_body = nil
+        return return_string
+      end # render_uzuuzu
+      
+      def uzuuzu_csses(resource)
+        resource ||= self.info
+        csses = []
+        resource.csses.each do |css|
+          if css.url.nil?
+            csses << UzuUzu::CssController.r(css.id)
+          else
+            csses << css.url
+          end
+        end
+        csses
+      end # uzuuzu_csses
+      
+      def uzuuzu_javascripts(resource)
+        resource ||= self.info
+        javascripts = []
+        resource.javascripts.each do |javascript|
+          if javascript.url.nil?
+            javascripts << UzuUzu::JavascriptController.r(javascript.id)
+          else
+            javascripts << javascript.url
+          end
+        end
+        javascripts
+      end # uzuuzu_javascripts
+      
+    end # UzuUzu
+  end # Helper
+end # UzuUzu

data/lib/uzuuzu/helper/xhtml.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+module UzuUzu
+  module Helper
+    module XHtml
+      #
+      #
+      #
+      def css(name, media='screen')
+        if name =~ /^http/
+          "<link href=\"#{name}\" media=\"#{media}\" rel=\"stylesheet\" type=\"text/css\" />"
+        else
+          "<link href=\"/css/#{name}.css\" media=\"#{media}\" rel=\"stylesheet\" type=\"text/css\" />"
+        end
+      end
+
+      #
+      #
+      #
+      def css_for(*args)
+        args.map{|arg| css(*arg) }.join("\n")
+      end
+
+      #
+      #
+      #
+      def js(name)
+        if name =~ /^http/
+          "<script src=\"#{name}\" type=\"text/javascript\"></script>"
+        else
+          "<script src=\"/js/#{name}.js\" type=\"text/javascript\"></script>"
+        end
+      end
+
+      #
+      #
+      #
+      def js_for(*args)
+        args.map{|arg| js(*arg) }.join("\n")
+      end
+
+    end
+  end
+end

data/lib/uzuuzu/model/remote_user.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+module UzuUzu
+  class RemoteUser
+    attr_reader :id
+    attr_reader :user_id
+    attr_reader :ip
+    attr_reader :type
+    attr_reader :domain
+
+
+    def self.open_id
+      return nil
+    end
+
+    def self.oauth
+      return nil
+    end
+    
+    def self.authenticate(request)
+
+      open_id = request[:open_id]
+      unless open_id.empty?
+        # TODO::open_id
+        return nil
+      end
+
+      oauth = request[:oauth]
+      unless oauth.empty?
+        # TODO::oauth
+        return nil
+      end
+
+      unless request.ssl?
+        return nil
+      end
+
+      user_id = request[:user_id]
+      password = request[:password]
+      user = User.authenticate(user_id, password)
+      
+      if user.nil?
+        return nil
+      end
+      RemoteUser.new(user,request.ip)
+    end #self.authenticate
+    
+    def initialize(user, ip)
+      @id = user.id
+      @user_id = user.user_id
+      @admin = user.admin
+      @domain = user.domain
+      @type = user.type
+      @ip = ip
+    end #new
+
+    def admin?
+      if @admin
+        true
+      end
+    end
+    
+    def authorized?(request)
+      return false if request.cookies[:remenber_login.to_s].nil?
+      return false unless @ip == request.ip
+      return true
+    end #authorized?
+    
+  end #RemoteUser
+end #UzuUzu

data/lib/uzuuzu/uzuuzu-core.rb

@@ -1,7 +1,16 @@
 
+require 'uzuuzu/wrapper/object'
 require 'uzuuzu/wrapper/uzuuzu'
+require 'uzuuzu/wrapper/environments'
 require 'uzuuzu/wrapper/logger'
 require 'uzuuzu/wrapper/mailer'
 require 'uzuuzu/wrapper/memcache'
 require 'uzuuzu/wrapper/datastore'
-require 'uzuuzu/wrapper/controller'
+require 'uzuuzu/wrapper/request'
+require 'uzuuzu/wrapper/response'
+require 'uzuuzu/wrapper/controller'
+require 'uzuuzu/wrapper/helper'
+require 'uzuuzu/wrapper/application'
+
+
+

data/lib/uzuuzu/wrapper/application.rb

@@ -0,0 +1,282 @@
+# coding: utf-8
+
+module UzuUzu
+  #
+  #
+  #
+  class Application
+    
+    #
+    attr_accessor :name
+    #
+    attr_accessor :config_file
+    #
+    attr_accessor :environments
+    #
+    attr_accessor :controllers
+    #
+    attr_accessor :before_filters
+    #
+    attr_accessor :after_filters
+    #
+    attr_accessor :helpers
+    #
+    attr_accessor :views
+    
+    def self.current
+      Thread.current[:application]
+    end
+    
+    #
+    #
+    #
+    def initialize(options={})
+      Thread.current[:application] = self
+      options.each do |key, value|
+        case(key)
+        when :name, 'name'
+          @name = value
+        when :config, 'config'
+          @config_file = value
+        end
+      end if options.kind_of?(Hash)
+      @name ||= :uzuuzu
+      @environments = Environments.new(@config_file)
+      UzuUzu.apps[@name] = self
+      yield self if block_given?
+    end # initialize
+
+    def controllers
+      @controllers ||= [UzuUzu::Controller]
+    end
+
+    def before_filters
+      @before_filters ||= [UzuUzu::Controller.method(:before_all)]
+    end
+
+    def after_filters
+      @after_filters ||= [UzuUzu::Controller.method(:after_all)]
+    end
+
+    def helpers
+      @helpers ||= [
+                     Rack::Utils,
+                     UzuUzu::Helper::Controller,
+                     UzuUzu::Helper::Renderer,
+                     UzuUzu::Helper::Localize,
+                     UzuUzu::Helper::Route,
+                     UzuUzu::Helper::UzuUzuPage,
+                     UzuUzu::Helper::XHtml
+                   ]
+    end
+    
+    def views
+      @views ||= ['./view']
+    end
+
+    #
+    #
+    #
+    def call(env)
+      Thread.current[:application] = self
+      request = UzuUzu::Request.new(env)
+      response = UzuUzu::Response.new
+      clazz = find_controller(env)
+      if clazz.blank?
+        return not_found(request, response)
+      end
+
+      is_send = false
+      action_return = nil
+      render = nil
+      clazz.each do |map|
+        controller_class = map[:clazz]
+        query = map[:query]
+        route = map[:route]
+        controller = controller_class.new
+        di_helpers(controller)
+
+        action, query = find_action(controller, query)
+        next if action.blank?
+        is_send = true
+        di_thread(request, response, controller, action, query, route)
+        di_instance(request, response, controller, action, query, route)
+        action_return = send_action(request, response, controller, action, query)
+        if response.body.blank?
+          render = controller.render(action)
+        end
+        break
+      end
+      
+      unless is_send
+        return not_found(request, response)
+      end
+      if response.status == 200 and response.body.blank?
+        response.write render || action_return
+      end
+
+      response.finish
+    end # call
+
+    #
+    #
+    #
+    def find_controller(env)
+      classies = []
+      request_paths = env['PATH_INFO'].split('/')
+      request_paths.shift if request_paths[0].blank?
+      
+      controllers.reverse.each do |c|
+        if c.instance_of?(Module) or c.instance_of?(Class)
+          controller_str = []
+          request_paths.each_with_index do |request_path, index|
+            next if request_path.blank?
+            controller_str << request_path.camel_case
+            c_str = controller_str.join('::')
+            next if c_str == 'Index'
+            route = "#{env['SCRIPT_NAME']}/#{request_paths[0..index].join('/')}"
+            query = request_paths[(index+1)..-1]
+            begin
+              if c.const_defined?(c_str)
+                classies <<  {:clazz => c.module_eval(c_str),
+                              :route => route,
+                              :query => query}
+              end
+            rescue NameError => e
+              begin
+                if c.const_defined?("#{c_str}Controller")
+                  classies << {:clazz => c.module_eval("#{c_str}Controller"),
+                               :route => route,
+                               :query => query}
+                end
+              rescue NameError => e
+              end
+            end
+          end
+          if c.const_defined?('Index')
+            classies << {:clazz => c.module_eval("Index"),
+                         :route => env['SCRIPT_NAME'],
+                         :query => request_paths}
+          elsif c.const_defined?('IndexController')
+            classies << {:clazz => c.module_eval("Index"),
+                         :route => env['SCRIPT_NAME'],
+                         :query => request_paths}
+          end
+        else
+          UzuUzu.logger.warn "routing miss controllers only Module or Class : #{c}"
+        end
+      end
+      classies
+    end # find_controller
+
+    #
+    #
+    #
+    def di_helpers(controller)
+      helpers.each do |helper|
+        controller.class.send(:include, helper)
+      end
+    end # di_helpers
+    
+    #
+    #
+    #
+    def di_instance(request, response, controller, action, query, route)
+      controller.instance_variable_set(:@_application, self)
+      controller.instance_variable_set(:@_request, request)
+      controller.instance_variable_set(:@_response, response)
+      controller.instance_variable_set(:@_action, action)
+      controller.instance_variable_set(:@_query, query)
+      controller.instance_variable_set(:@_route, route)
+    end # di_instance
+    
+    def di_thread(request, response, controller, action, query, route)
+      current = Thread.current
+      current[:request] = request
+      current[:response] = response
+      current[:controller] = controller
+      current[:action] = action
+      current[:query] = query
+      current[:route] = route
+    end
+    
+    def get_thread_by_di
+      current = Thread.current
+      [current[:request], current[:response], current[:controller], current[:action], current[:query], current[:route]]
+    end
+
+    #
+    #
+    #
+    def find_action(controller, query)
+      action = nil
+      query = query.map do |q|
+        q.sub(/\.\w+$/, '')
+      end
+      if query[0] and controller.respond_to?(query[0])
+        action = query.shift
+      end
+      if action.nil? and controller.respond_to?(:index)
+        action = 'index'
+      end
+      
+      unless action.nil?
+        arity = controller.method(action).arity
+        unless (arity >= 0 and query.size == arity) or
+               (arity < 0 and query.size >= ((-1 * arity)-1))
+          if (not action == 'index') and controller.respond_to?(:index)
+            query.unshift(action)
+            action = 'index'
+            if controller.respond_to?(action)
+              arity = controller.method(action).arity
+              unless (arity >= 0 and query.size == arity) or
+                     (arity < 0 and query.size >= ((-1 * arity)-1))
+                action = nil
+              end
+            else
+              action = nil
+            end
+          else
+            action = nil
+          end
+        end
+      end
+      [action, query]
+    end # find_action
+
+    #
+    #
+    #
+    def send_action(request, response, controller, action, query)
+      value = nil
+      catch(:finish) do
+        before_filters.each do |filter|
+          filter.call if filter.respond_to?(:call)
+        end
+        controller.send(:before, []) if controller.respond_to?(:before)
+        value = controller.send(action, *query)
+        controller.send(:after, []) if controller.respond_to?(:after)
+        after_filters.reverse.each do |filter|
+          filter.call if filter.respond_to?(:call)
+        end
+      end
+      value
+    end # send_action
+    
+    def error(code, request, response)
+      UzuUzu.logger.debug "error : #{code}"
+      uri = "#{request.scheme}://#{request.host}"
+      if (request.scheme == 'https' and request.port != 443) or
+          (request.scheme == 'http' and request.port != 80)
+        uri << ":#{request.port}"
+      end
+      uri << "#{request.env["SCRIPT_NAME"]}/error/#{code}"
+      response.redirect(uri)
+      response.finish
+    end
+
+    def not_found(request, response)
+      error(404, request, response)
+    end
+  end # Application
+end # UzuUzu