tzispa 0.6.1 → 0.7.0

data/lib/tzispa/controller/api.rb

@@ -7,114 +7,120 @@ require 'tzispa/controller/exceptions'
 require 'tzispa/helpers/response'
 require 'tzispa/utils/string'
 
-
 module Tzispa
   module Controller
 
     class ControllerException < StandardError; end
 
     class Api < Base
-
-      using Tzispa::Utils
+      using Tzispa::Utils::TzString
 
       include Tzispa::Helpers::Response
 
       def dispatch!
-        handler_name, domain_name = context.router_params[:handler].split('.').reverse
-        domain = domain_name.nil? ? context.app.domain : Tzispa::Domain.new(name: domain_name)
         verb = context.router_params[:verb]
         predicate = context.router_params[:predicate]
-        handler = self.class.handler_class(domain, handler_name).new(context)
+        handler = prepare_handler
         handler.run! verb, predicate
-        send(handler.response_verb, handler) if handler.response_verb
+        send(handler.type, handler) if handler.type
         response.finish
       end
 
-      def redirect(handler)
-        url = if handler.data && !handler.data.strip.empty?
-          handler.data.start_with?('#') ? "#{request.referer}#{handler.data}" : handler.data
+      def prepare_handler
+        self.class.handler_class(request_method, domain, handler_name).new(context)
+      end
+
+      def domain
+        _, domain_name = context.router_params[:handler].split('.').reverse
+        domain_name ? Tzispa::Domain.new(name: domain_name) : context.app.domain
+      end
+
+      def handler_name
+        context.router_params[:handler].split('.').last
+      end
+
+      def handler_redirect_url(url)
+        if url && !url.strip.empty?
+          url.start_with?('#') ? "#{request.referer}#{url}" : url
         else
           request.referer
-        end        
-        context.flash << handler.message if config.sessions&.enabled && handler.error?
-        context.redirect url, config.absolute_redirects, response
+        end
+      end
+
+      def redirect(handler)
+        api_flash(handler.message) if handler.error?
+        context.redirect handler.redirect_url(handler.data), config.absolute_redirects, response
       end
 
       def html(handler)
-        content_type :htm
-        context.flash << handler.message if config.sessions&.enabled && handler.error?
-        response.body << handler.data
-        set_api_headers handler.status
+        content = handler.error? ? handler.message : handler.data
+        api_response :htm, content, handler.status, handler.error
       end
 
       def json(handler)
-        content_type :json
-        data = ::String === handler.data ? JSON.parse(handler.data) : handler.data.to_json
-        unless handler.error?
-          response.body << data
-        else
-          response.body << Hash[:__error, true, :__error_msg, handler.message, :__error_code, handler.status].to_json
-        end
-        set_api_headers handler.status
+        content = if handler.error?
+                    { error_message: handler.message,
+                      error_code: handler.error }.to_json
+                  else
+                    handler.data.is_a?(::String) ? JSON.parse(handler.data) : handler.data.to_json
+                  end
+        api_response :json, content, handler.status, handler.error
       end
 
       def text(handler)
-        content_type :text
-        context.flash << handler.message if config.sessions&.enabled && handler.error?
-        response.body << handler.data
-        set_api_headers handler.status
+        content = handler.error? ? handler.message : handler.data
+        api_response :text, content, handler.status, handler.error
       end
 
       def download(handler)
         send_file handler.data[:path], handler.data
       end
 
-      class << self
+      def api_flash(message)
+        context.flash << message if config.sessions&.enabled
+      end
+
+      def api_response(type, content, status = nil, error = nil)
+        content_type type
+        response.body << content
+        response.status = status if status
+        api_headers error
+      end
 
+      def request_method
+        context.request_method.downcase
+      end
+
+      class << self
         def handler_class_name(handler_name)
           "#{handler_name.camelize}Handler"
         end
 
-        def handler_class_file(domain, handler_name)
-          "#{domain.path}/api/#{handler_name}.rb"
+        def handler_class_file(domain, handler_name, request_method)
+          "#{domain.path}/api/#{request_method}/#{handler_name}.rb"
         end
 
-        def handler_namespace(domain)
-          "#{domain.name.to_s.camelize}::Api"
+        def handler_namespace(domain, request_method)
+          "#{domain.name.to_s.camelize}::Api::#{request_method.capitalize}"
         end
 
-        def handler_class(domain, handler_name)
-          domain.require "api/#{handler_name}"
-          "#{handler_namespace domain}::#{handler_class_name handler_name}".constantize
+        def handler_class(request_method, domain, handler_name)
+          domain.require "api/#{request_method}/#{handler_name}"
+          "#{handler_namespace domain, request_method}::#{handler_class_name handler_name}"
+            .constantize
         end
-
-        def generate_handler(domain, name)
-          raise "The handler '#{name}' already exist" if File.exist?(handler_class_file)
-          File.open(handler_class_file(domain, name), "w") { |f|
-            handler_code = String.new
-            f.puts handler_code.indenter("require 'tzispa/api/handler'\n\n")
-            level = 0
-            handler_namespace.split('::').each { |ns|
-              f.puts handler_code.indenter("module #{ns}\n", level > 0 ? 2 : 0).to_s
-              level += 1
-            }
-            f.puts handler_code.indenter("\nclass #{handler_class_name} < Tzispa::Api::Handler\n\n", 2)
-            f.puts handler_code.indenter("end\n\n")
-            handler_namespace.split('::').each { |ns|
-              f.puts handler_code.unindenter("end\n", 2)
-            }
-          }
-        end
-
       end
 
       private
 
-      def set_api_headers(status)
-        response['X-API'] = "#{context.router_params[:handler]}:#{context.router_params[:verb]}:#{context.router_params[:predicate]}"
-        response['X-API-STATE'] = "#{status}"
+      def api_headers(error = nil)
+        handler = context.router_params[:handler]
+        verb = context.router_params[:verb]
+        predicate = context.router_params[:predicate]
+        response['X-API'] = "#{handler}:#{verb}:#{predicate}"
+        response['X-API-SR'] = error.to_s if error
       end
-
     end
+
   end
 end

data/lib/tzispa/controller/auth_layout.rb

@@ -1,37 +1,13 @@
 # frozen_string_literal: true
 
-require 'tzispa_rig'
-require 'tzispa/controller/base'
-require 'tzispa/controller/exceptions'
-require 'tzispa/helpers/response'
-require 'tzispa_rig'
+require 'tzispa/controller/layout'
 
 module Tzispa
   module Controller
-    class AuthLayout < Base
-      include Tzispa::Helpers::Response
-
-      def render!
-        if (layout_name == login_layout) || context.logged?
-          rig = Tzispa::Rig::Engine.layout name: layout_name, domain: application.domain, content_type: context.router_params[:format] || config.default_format
-          response.body << rig.render(context)
-          content_type rig.content_type
-        else
-          context.redirect login_layout, true, response
-        end
-      end
-
-      private
-
-      def layout_name
-        context.layout || config.default_layout
-      end
-
-      def login_layout
-        config.login_layout
-      end
-
 
+    class AuthLayout < Layout
+      before :login_redirect
     end
+
   end
 end

data/lib/tzispa/controller/base.rb

@@ -2,7 +2,8 @@
 
 require 'forwardable'
 require 'tzispa/helpers/error_view'
-
+require 'tzispa/http/context'
+require 'tzispa/environment'
 
 module Tzispa
   module Controller
@@ -12,48 +13,84 @@ module Tzispa
 
       include Tzispa::Helpers::ErrorView
 
-      attr_reader :context, :application
-      def_delegators :@context, :request, :response, :config
+      attr_reader :context, :application, :callmethod
+      def_delegators :@context, :request, :response, :config,
+                     :login_redirect, :unauthorized_but_logged
 
-      def initialize(app, callmethod=nil)
+      def initialize(app, callmethod = nil)
         @callmethod = callmethod
         @application = app
       end
 
       def call(env)
         @context = Tzispa::Http::Context.new(@application, env)
-        #env[Tzispa::ENV_TZISPA_CONTEXT] = @context
-        #@context = env[Tzispa::ENV_TZISPA_CONTEXT]
-        invoke @callmethod if @callmethod
+        invoke if callmethod
         response.finish
       end
 
+      class << self
+        def before(*args)
+          (@before_chain ||= []).tap do |bef|
+            args&.each do |s|
+              s = s.to_sym
+              bef << s unless bef.include?(s)
+            end
+          end
+        end
+      end
+
       private
 
-      def invoke(callmethod)
-        debug_info = nil
-        status = catch(:halt) {
-          begin
-            send "#{@callmethod}"
-          rescue Tzispa::Rig::NotFound => ex
-            context.logger.info "#{ex.message} (#{ex.class})"
-            404
-          rescue StandardError, ScriptError => ex
-            context.logger.error "#{ex.message} (#{ex.class}):\n #{ex.backtrace.join("\n\t") if ex.respond_to?(:backtrace) && ex.backtrace}"
-            debug_info = debug_info(ex) if config.developing
-            500
-          end
+      def invoke
+        prepare_response catch(:halt) {
+          do_before
+          send callmethod
         }
+      rescue Tzispa::Rig::NotFound => ex
+        prepare_client_error(404, ex)
+      rescue StandardError, ScriptError, SecurityError => ex
+        prepare_server_error(500, ex)
+      end
+
+      def prepare_response(status, content = nil)
         response.status = status if status.is_a?(Integer)
         if response.client_error?
-          response.body = error_page(context.domain, status: response.status)
+          prepare_client_error(status)
         elsif response.server_error?
-          response.body = debug_info ?
-            debug_info :
-            error_page(context.domain, status: response.status)
+          prepare_server_error(status)
+        elsif content
+          response.body = content
+        end
+      end
+
+      def do_before
+        self.class.before.each { |hook| send hook }
+      end
+
+      def prepare_client_error(status, error = nil)
+        status.tap do |code|
+          context.logger.info log_format(code, error.to_s) if error
+          response.body = error_page(context.domain, status: code)
         end
       end
 
+      def prepare_server_error(status, error = nil)
+        status.tap do |code|
+          context.logger.error log_format(code, error_log(error)) if error
+          response.body = if error && Tzispa::Environment.development?
+                            debug_info(error)
+                          else
+                            error_page(context.domain, status: code)
+                          end
+        end
+      end
+
+      def log_format(status, msg)
+        String.new.tap do |str|
+          str << "[#{context.request.ip} #{DateTime.now}] #{context.request.request_method}"
+          str << " #{context.request.fullpath} #{status}\n#{msg}"
+        end
+      end
     end
 
   end

data/lib/tzispa/controller/exceptions.rb

@@ -2,10 +2,9 @@ module Tzispa
   module Controller
     module Error
 
-      class ControllerError < StandardError; end;
-      class Http < ControllerError; end;
-      class Http_404 < Http; end;
-      class InvalidSign < ControllerError; end;
+      class ControllerError < StandardError; end
+      class Http < ControllerError; end
+      class InvalidSign < ControllerError; end
 
     end
   end

data/lib/tzispa/controller/http_error.rb

@@ -7,14 +7,11 @@ module Tzispa
   module Controller
 
     class HttpError < Base
-
       include Tzispa::Helpers::Response
 
       def error_404
         not_found
       end
-
-
     end
 
   end

data/lib/tzispa/controller/layout.rb

@@ -4,7 +4,6 @@ require 'tzispa_rig'
 require 'tzispa/controller/base'
 require 'tzispa/controller/exceptions'
 require 'tzispa/helpers/response'
-require 'tzispa_rig'
 
 module Tzispa
   module Controller
@@ -12,7 +11,9 @@ module Tzispa
       include Tzispa::Helpers::Response
 
       def render!
-        rig = Tzispa::Rig::Engine.layout name: layout_name, domain: application.domain, content_type: context.router_params[:format] || config.default_format
+        rig = Tzispa::Rig::Engine.layout name: layout_name,
+                                         domain: application.domain,
+                                         content_type: context.router_params[:format] || config.default_format
         response.body << rig.render(context)
         content_type rig.content_type
       end
@@ -22,8 +23,7 @@ module Tzispa
       def layout_name
         context.layout || config.default_layout
       end
-
-
     end
+
   end
 end

data/lib/tzispa/domain.rb

@@ -3,47 +3,52 @@
 require 'tzispa/utils/string'
 
 module Tzispa
-  class Domain
 
-    using Tzispa::Utils
+  class Domain
+    using Tzispa::Utils::TzString
 
     attr_reader :name, :root
 
-    DEFAULT_DOMAIN_NAME   = :default
-    DEFAULT_DOMAINS_ROOT  = :apps
-
-
-    def initialize(name=DEFAULT_DOMAIN_NAME, root=DEFAULT_DOMAINS_ROOT)
+    def initialize(name)
       @name = name
-      @root = root
+      @root = "#{Tzispa::Environment.instance.root}/#{Tzispa::Environment.instance.apps_path}"
+      instance_eval "module ::#{name.to_s.capitalize}; end"
+    end
+
+    def setup
+      require_dir
+      require_dir 'helpers'
+      require_dir 'services'
+      require_dir 'api'
+      require_dir 'middleware'
     end
 
     def path
-      "#{root.to_s.downcase}/#{name.to_s.downcase}".freeze
+      @path ||= root % name.to_s.downcase
     end
 
     def require(file)
-      Kernel.require "./#{path}/#{file}"
+      Kernel.require "#{path}/#{file}"
     end
 
     def load(file)
-      Kernel.load "./#{path}/#{file}.rb"
+      Kernel.load "#{path}/#{file}.rb"
     end
 
     def require_dir(dir = nil)
-      rqpath = dir ? "/#{path}/#{dir}" : "/#{path}"
-      Dir[".#{rqpath}/*.rb"].each { |file|
+      rqpath = dir ? "#{path}/#{dir}" : path.to_s
+      Dir["#{rqpath}/*.rb"].each do |file|
         name = file.split('/').last.split('.').first
-        Kernel.require ".#{rqpath}/#{name}"
-      }
+        Kernel.require "#{rqpath}/#{name}"
+      end
     end
 
     def load_dir(dir = nil)
-      rqpath = dir ? "/#{path}/#{dir}" : "/#{path}"
-      Dir[".#{rqpath}/*.rb"].each { |file|
+      rqpath = dir ? "#{path}/#{dir}" : path.to_s
+      Dir["#{rqpath}/*.rb"].each do |file|
         name = file.split('/').last
-        Kernel.load ".#{rqpath}/#{name}"
-      }
+        Kernel.load "#{rqpath}/#{name}"
+      end
     end
 
     def include(cmod)
@@ -51,13 +56,12 @@ module Tzispa
     end
 
     def self.require(domain, file)
-      self.new(name: domain).require(file)
+      new(name: domain).require(file)
     end
 
     def self.load(domain, file)
-      self.new(name: domain).load(file)
+      new(name: domain).load(file)
     end
-
-
   end
+
 end

data/lib/tzispa/env.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'dotenv'
+
+module Tzispa
+
+  class Env
+    def initialize(env: ENV)
+      @env = env
+    end
+
+    def [](key)
+      @env[key]
+    end
+
+    def []=(key, value)
+      @env[key] = value
+    end
+
+    def load!(path)
+      return unless defined?(Dotenv)
+
+      contents = ::File.open(path, 'rb:bom|utf-8', &:read)
+      parsed   = Dotenv::Parser.call(contents)
+
+      parsed.each do |k, v|
+        next if @env.key?(k)
+        @env[k] = v
+      end
+      nil
+    end
+  end
+
+end