tzispa 0.7.6 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13911ddd5b938320efb3e6aa971d996be88581e5
-  data.tar.gz: a054ae603791f5a57a66b40a837ea5fd95b254cb
+  metadata.gz: 4afde718b4afe167e5e25031d064aa92c826162b
+  data.tar.gz: 51c74b98a6a21715a6cd1f23dcf70b5974c1211b
 SHA512:
-  metadata.gz: 28359f1534f2799ab711386a2caab2641bb047b663a864de73c815851192e772e520acc3d71831c2cabe3143e4706b3fa4702975a9d8b7e147f85212b55c4135
-  data.tar.gz: 976f8d1b4b7e18af9887e3400d56320de2a45e300822b696846441dc7f2557f35eed6a56eb649722d02f711dcc91f88f6b7e611aa0004385ff073c48f6b6cd77
+  metadata.gz: 63d7bb48cd522eacd349ca5284271fc30ae263558f82a959e4308e31a5ed5e9de56b7cb77489b9bd07faf6382394f8243cee3dabe7b4dd5b399911f6818654fb
+  data.tar.gz: 93450d79ad98a19086ff28b9555efb179bb3da19f4565e8157569b5ad1d44085dc9ee2978da87c4ba3724a8e88cb2efab3277e43ad4c413bb85be20420032fe7

data/CHANGELOG.md

@@ -2,6 +2,11 @@ Tzispa
 
 General purpose web framework
 
+## v0.8.0
+- introducing support for other template engines
+- improve errors log
+- bugs fixes
+
 ## v0.7.6
 - added custom error pages option in base controller
 - disable custom error page in the api controller

data/lib/tzispa/api/handler.rb

@@ -29,14 +29,15 @@ module Tzispa
 
       using Tzispa::Utils::TzString
 
-      attr_reader :context, :type, :data, :error, :status
+      attr_reader :context, :type, :data, :error, :rescue_hook, :status
       def_delegators :@context, :request, :response, :app, :repository,
-                     :config, :logger, :unauthorized_but_logged, :login_redirect
+                     :config, :logger, :error_log, :info_log
 
       def initialize(context)
         @context = context
         @error = nil
         @status = nil
+        @rescue_hook = nil
       end
 
       def result(type:, data: nil)
@@ -56,20 +57,31 @@ module Tzispa
         result type: :redirect, data: data
       end
 
-      def error_status(code, http_status = nil)
-        @error = code
+      def error_status(error_code, http_status = nil)
+        @error = error_code
         @status = http_status
-        result_json error_message: message, error_code: code
+        result_json error_message: error_message
+      end
+      # alias result_error error_status
+
+      def on_error(http_error, error_code = nil, logger = nil)
+        @rescue_hook = { logger: logger, error_code: error_code, http_error: http_error }
       end
-      alias result_error error_status
 
       def run!(verb, predicate = nil)
         raise UnknownHandlerVerb.new(verb, self.class.name) unless provides? verb
         raise InvalidSign if sign_required? && !sign_valid?
         do_before
-        # process compound predicates
-        args = predicate ? predicate.split(',') : nil
-        send verb, *args
+        begin
+          send verb, *(predicate&.split(','))
+        rescue => err
+          if rescue_hook
+            send(rescue_hook[:logger], err) if rescue_hook.include? :logger
+            send(rescue_hook[:http_error], rescue_hook[:error_code])
+          else
+            raise
+          end
+        end
         do_after
       end
 

data/lib/tzispa/api/handler_error.rb

@@ -15,7 +15,7 @@ module Tzispa
         @error && @error != HANDLER_OK
       end
 
-      def message
+      def error_message
         I18n.t(error_id, default: error.to_s) if error
       end
 
@@ -23,52 +23,52 @@ module Tzispa
         "#{self.class.name.dottize}.#{error}" if error
       end
 
-      def http_bad_request(error = nil)
-        error_status error || :bad_requuest, 400
+      def http_bad_request(code = nil)
+        error_status code || :bad_request, 400
       end
 
-      def http_unauthorized(error = nil)
-        error_status error || :unauthorized, 401
+      def http_unauthorized(code = nil)
+        error_status code || :unauthorized, 401
       end
 
-      def http_forbidden(error = nil)
-        error_status error || :forbidden, 403
+      def http_forbidden(code = nil)
+        error_status code || :forbidden, 403
       end
 
-      def http_not_found(error = nil)
-        error_status error || :not_found, 404
+      def http_not_found(code = nil)
+        error_status code || :not_found, 404
       end
 
-      def http_not_aceptable(error = nil)
-        error_status error || :not_acceptable, 406
+      def http_not_aceptable(code = nil)
+        error_status code || :not_acceptable, 406
       end
 
-      def http_conflict(error = nil)
-        error_status error || :conflict, 409
+      def http_conflict(code = nil)
+        error_status code || :conflict, 409
       end
 
-      def http_gone(error = nil)
-        error_status error || :gone, 410
+      def http_gone(code = nil)
+        error_status code || :gone, 410
       end
 
-      def http_token_required(error = nil)
-        error_status error || :token_required, 499
+      def http_token_required(code = nil)
+        error_status code || :token_required, 499
       end
 
-      def http_server_error(error = nil)
-        error_status error || :internal_server_error, 500
+      def http_server_error(code = nil)
+        error_status code || :internal_server_error, 500
       end
 
-      def http_not_implemented(error = nil)
-        error_status error || :not_implemented, 501
+      def http_not_implemented(code = nil)
+        error_status code || :not_implemented, 501
       end
 
-      def http_bad_gateway(error = nil)
-        error_status error || :bad_gateway, 502
+      def http_bad_gateway(code = nil)
+        error_status code || :bad_gateway, 502
       end
 
-      def http_service_unavailable(error = nil)
-        error_status error || :service_unavailable, 503
+      def http_service_unavailable(code = nil)
+        error_status code || :service_unavailable, 503
       end
 
     end

data/lib/tzispa/app.rb

@@ -4,9 +4,9 @@ require 'forwardable'
 require 'logger'
 require 'i18n'
 require 'tzispa/domain'
-require 'tzispa/route_set'
 require 'tzispa/config/app_config'
 require 'tzispa/config/db_config'
+require 'tzispa/engine'
 require 'tzispa_data'
 
 module Tzispa
@@ -14,10 +14,10 @@ module Tzispa
   class Application
     extend Forwardable
 
-    attr_reader :domain, :logger, :map_path
+    include Tzispa::Engine
 
+    attr_reader :domain, :logger, :map_path, :engine, :routes
     def_delegators :@domain, :name, :path
-    def_delegators :@routes, :routing, :index, :api, :signed_api, :layout
 
     class << self
       alias __new__ :new
@@ -49,9 +49,10 @@ module Tzispa
       end
     end
 
-    def initialize(appid, on: nil, &block)
+    def initialize(appid, engine:, on: nil, &block)
       @domain = Domain.new(appid)
       @map_path = on
+      @engine = engine
       instance_eval(&block) if block
     end
 
@@ -62,11 +63,11 @@ module Tzispa
     def load!
       tap do |app|
         app.class.synchronize do
-          logging
-          load_locales
+          logging_setup
+          locales_setup
           repository&.load!(domain)
           domain.setup
-          routes.setup
+          routes_setup
         end
       end
     end
@@ -75,18 +76,10 @@ module Tzispa
       self.class[domain]
     end
 
-    def default_layout?(layout)
-      config.default_layout.to_sym == layout
-    end
-
     def env
       Tzispa::Environment.instance
     end
 
-    def routes
-      @routes ||= RouteSet.new(self, map_path)
-    end
-
     def config
       @config ||= Config::AppConfig.new(@domain).load!
     end
@@ -100,13 +93,17 @@ module Tzispa
 
     private
 
-    def logging
+    def routes_setup
+      @routes = send :"#{engine}_routes", self, map_path
+    end
+
+    def logging_setup
       return unless config&.logging&.enabled
       @logger = Logger.new("logs/#{domain.name}.log", config.logging&.shift_age)
       @logger.level = Tzispa::Environment.development? ? Logger::DEBUG : Logger::INFO
     end
 
-    def load_locales
+    def locales_setup
       return unless config.respond_to?(:locales)
       I18n.enforce_available_locales = false
       I18n.load_path += Dir['config/locales/*.yml', "#{domain.path}/locales/*.yml"]

data/lib/tzispa/commands/api.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require 'tzispa/controller/api'
+require 'tzispa/engine/rig/api'
 require 'tzispa/commands/command'
 require 'tzispa/utils/indenter'
 
@@ -19,10 +19,10 @@ module Tzispa
       end
 
       def generate
-        file_name = Tzispa::Controller::Api.handler_class_file(domain, name, verb)
+        file_name = Tzispa::Engine::Rig::Api.handler_class_file(domain, name, verb)
         raise "The handler '#{name}' already exist" if File.exist?(file_name)
-        namespace = Tzispa::Controller::Api.handler_namespace(domain, verb)
-        class_name = Tzispa::Controller::Api.handler_class_name(name)
+        namespace = Tzispa::Engine::Rig::Api.handler_namespace(domain, verb)
+        class_name = Tzispa::Engine::Rig::Api.handler_class_name(name)
         create_file file_name, namespace, class_name
       end
 

data/lib/tzispa/controller/base.rb

@@ -1,87 +1,41 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'tzispa/helpers/error_view'
 require 'tzispa/helpers/hooks/before'
 require 'tzispa/helpers/hooks/after'
-require 'tzispa/http/context'
 require 'tzispa/environment'
+require 'tzispa/context'
 
 module Tzispa
   module Controller
 
     class Base
-      extend Forwardable
 
-      include Tzispa::Helpers::ErrorView
       include Tzispa::Helpers::Hooks::Before
       include Tzispa::Helpers::Hooks::After
 
-      attr_reader :context, :application, :callmethod, :custom_error
-      def_delegators :@context, :request, :response, :config,
-                     :login_redirect, :unauthorized_but_logged
+      attr_reader :application, :context, :context_class, :callmethod
 
-      def initialize(app, callmethod = nil, custom_error = true)
-        @callmethod = callmethod
+      def initialize(app, callmethod, context_class = Tzispa::Context)
         @application = app
-        @custom_error = custom_error
+        @callmethod = callmethod
+        @context_class = context_class
       end
 
       def call(env)
-        @context = Tzispa::Http::Context.new(@application, env)
-        invoke if callmethod
-        response.finish
+        @context = context_class.new(application, env)
+        invoke
       end
 
       private
 
       def invoke
-        prepare_response catch(:halt) {
+        catch(:halt) {
           do_before
           send callmethod
           do_after
         }
-      rescue Tzispa::Rig::NotFound => ex
-        prepare_response(404, error: ex)
-      rescue StandardError, ScriptError, SecurityError => ex
-        prepare_response(500, error: ex)
       end
 
-      def prepare_response(status, error: nil)
-        response.status = status if status.is_a?(Integer)
-        if context.client_error?
-          prepare_client_error(status, error)
-        elsif context.server_error?
-          prepare_server_error(status, error)
-        end
-      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) if custom_error
-        end
-      end
-
-      def prepare_server_error(status, error = nil)
-        status.tap do |code|
-          context.logger.error log_format(code, error_log(error)) if error
-          if custom_error
-            response.body = if error && Tzispa::Environment.development?
-                              debug_info(error)
-                            else
-                              error_page(context.domain, status: code)
-                            end
-          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/http.rb

@@ -0,0 +1,67 @@
+require 'forwardable'
+require 'tzispa/helpers/error_view'
+require 'tzispa/controller/base'
+require 'tzispa/http/context'
+
+module Tzispa
+  module Controller
+
+    class Http < Tzispa::Controller::Base
+      extend Forwardable
+
+      include Tzispa::Helpers::ErrorView
+
+      attr_reader :custom_errors
+      def_delegators :@context, :request, :response, :config
+
+      def initialize(app, callmethod, context_class = Tzispa::Http::Context, custom_errors = true)
+        super app, callmethod, context_class
+        @custom_errors = custom_errors
+      end
+
+      def call(env)
+        super
+        response.finish
+      end
+
+      private
+
+      def invoke
+        prepare_response super
+      rescue StandardError, ScriptError, SecurityError => ex
+        prepare_response(500, error: ex)
+      end
+
+      def prepare_response(status, error: nil)
+        response.status = status if status.is_a?(Integer)
+        if context.client_error?
+          prepare_client_error(status, error)
+        elsif context.server_error?
+          prepare_server_error(status, error)
+        end
+      end
+
+      def prepare_client_error(status, error = nil)
+        status.tap do |code|
+          context.info_log(error, code) if error
+          response.body = error_page(context.domain, status: code) if custom_errors
+        end
+      end
+
+      def prepare_server_error(status, error = nil)
+        status.tap do |code|
+          context.error_log(error, code) if error
+          if custom_errors
+            response.body = if error && Tzispa::Environment.development?
+                              debug_info(error)
+                            else
+                              error_page(context.domain, status: code)
+                            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tzispa/engine/rig/api.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tzispa/domain'
+require 'tzispa/controller/http'
+require 'tzispa/controller/exceptions'
+require 'tzispa/helpers/response'
+require 'tzispa/utils/string'
+require 'tzispa/engine/rig/context'
+
+module Tzispa
+  module Engine
+    module Rig
+
+      class ControllerException < StandardError; end
+
+      class Api < Tzispa::Controller::Http
+        using Tzispa::Utils::TzString
+
+        include Tzispa::Helpers::Response
+
+        def initialize(app)
+          super app, :dispatch!, Tzispa::Engine::Rig::Context, false
+        end
+
+        def dispatch!
+          verb = context.router_params[:verb]
+          predicate = context.router_params[:predicate]
+          handler = prepare_handler
+          handler.run! verb, predicate
+          send(handler.type || :empty, handler)
+        end
+
+        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
+        end
+
+        def empty(handler)
+          api_response handler.status
+        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 = handler.data unless handler.error?
+          api_response handler.status, content, :htm
+        end
+
+        def json(handler)
+          content = handler.data.is_a?(::String) ? JSON.parse(handler.data) : handler.data.to_json
+          api_response handler.status, content, :json
+        end
+
+        def text(handler)
+          content = handler.data unless handler.error?
+          api_response handler.status, content, :text
+        end
+
+        def download(handler)
+          send_file handler.data[:path], handler.data
+        end
+
+        def api_flash(message)
+          context.flash << message if config.sessions&.enabled
+        end
+
+        def api_response(status, content = nil, type = nil)
+          content_type(type) if type
+          response.body = content if content
+          response.status = status if status
+        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, request_method)
+            "#{domain.path}/api/#{request_method}/#{handler_name}.rb"
+          end
+
+          def handler_namespace(domain, request_method)
+            "#{domain.name.to_s.camelize}::Api::#{request_method.capitalize}"
+          end
+
+          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
+        end
+      end
+
+    end
+  end
+end

data/lib/tzispa/engine/rig/auth_layout.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'tzispa/engine/rig/layout'
+require 'tzispa/helpers/login'
+
+module Tzispa
+  module Engine
+    module Rig
+
+      class AuthLayout < Tzispa::Engine::Rig::Layout
+        include Tzispa::Helpers::Login
+
+        before :login_redirect
+      end
+
+    end
+  end
+end

data/lib/tzispa/engine/rig/context.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'tzispa/http/context'
+require 'tzispa/helpers/security'
+
+module Tzispa
+  module Engine
+    module Rig
+
+      class Context < Tzispa::Http::Context
+        include Tzispa::Helpers::Security
+
+        def layout
+          router_params&.fetch(:layout, nil)
+        end
+
+        def default_layout?(layout)
+          config.default_layout&.to_sym == layout
+        end
+
+        def layout_path(layout, params = {})
+          is_default = default_layout? layout
+          params = normalize_format(params.merge(layout: layout)) unless is_default
+          app.routes.path layout, params
+        end
+
+        def app_layout_path(app_name, layout, params = {})
+          is_default = app[app_name].default_layout? == layout
+          params = normalize_format(params.merge(layout: layout)) unless is_default
+          app[app_name].routes.path layout, params
+        end
+
+        def layout_canonical_url(layout, params = {})
+          "#{canonical_root}#{layout_path(layout, params)}"
+        end
+
+        def app_layout_canonical_url(app_name, layout, params = {})
+          "#{canonical_root}#{app_layout_path(app_name, layout, params)}"
+        end
+
+        def path_sign?(sign, *args)
+          sign == sign_array(args, config.salt)
+        end
+
+        def api(handler, verb, predicate = nil, sufix = nil, app_name = nil)
+          if app_name
+            app_canonical_url app_name, :api, handler: handler, verb: verb,
+                                              predicate: predicate, sufix: sufix
+          else
+            canonical_url :api, handler: handler, verb: verb,
+                                predicate: predicate, sufix: sufix
+          end
+        end
+
+        def sapi(handler, verb, predicate = nil, sufix = nil, app_name = nil)
+          if app_name
+            sign = sign_array [handler, verb, predicate], app[:app_name].config.salt
+            app_canonical_url app_name, :sapi, sign: sign, handler: handler,
+                                               verb: verb, predicate: predicate, sufix: sufix
+          else
+            sign = sign_array [handler, verb, predicate], app.config.salt
+            canonical_url :sapi, sign: sign, handler: handler,
+                                 verb: verb, predicate: predicate, sufix: sufix
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/tzispa/engine/rig/layout.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'tzispa_rig'
+require 'tzispa/controller/http'
+require 'tzispa/controller/exceptions'
+require 'tzispa/helpers/response'
+require 'tzispa/engine/rig/context'
+
+module Tzispa
+  module Engine
+    module Rig
+
+      class Layout < Tzispa::Controller::Http
+        include Tzispa::Helpers::Response
+
+        def initialize(app)
+          super app, :render!, Tzispa::Engine::Rig::Context, true
+        end
+
+        def render!
+          layout_template.tap do |rig|
+            response.body << rig.render(context)
+            content_type rig.content_type
+          end
+        end
+
+        private
+
+        def layout_template
+          Tzispa::Rig::Factory.layout name: layout_name,
+                                      domain: application.domain,
+                                      content_type: context.router_params[:format] ||
+                                                   config.default_format
+        end
+
+        def invoke
+          super
+        rescue Tzispa::Rig::NotFound => ex
+          prepare_response(404, error: ex)
+        end
+
+        def layout_name
+          context.layout || config.default_layout
+        end
+      end
+
+    end
+  end
+end

data/lib/tzispa/engine/rig/router.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'tzispa/route_set'
+
+module Tzispa
+  module Engine
+    module Rig
+
+      class Router < Tzispa::RouteSet
+        def initialize(app, root = nil)
+          super app, root, 'Tzispa::Engine::Rig'
+        end
+
+        def index(path, controller: nil, methods: nil)
+          add :index, path, controller || 'layout', methods: methods
+        end
+
+        def layout(layout, path, controller: nil, methods: nil)
+          add layout, path, controller || 'layout', methods: methods,
+                                                    matching: { layout: layout.to_s }
+        end
+
+        def api(path, controller: nil, methods: nil)
+          add :api, path, controller || 'api', methods: methods
+        end
+
+        def signed_api(path, controller: nil, methods: nil)
+          add :sapi, path, controller || 'api', methods: methods
+        end
+      end
+
+    end
+  end
+end

data/lib/tzispa/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'tzispa/engine/rig/router'
+
+module Tzispa
+  module Engine
+
+    def rig_routes(app, map_path)
+      Rig::Router.new(app, map_path).setup
+    end
+
+  end
+end

data/lib/tzispa/http/context.rb

@@ -6,7 +6,6 @@ require 'tzispa/http/response'
 require 'tzispa/http/request'
 require 'tzispa/helpers/response'
 require 'tzispa/helpers/session'
-require 'tzispa/helpers/security'
 
 module Tzispa
   module Http
@@ -15,7 +14,6 @@ module Tzispa
       extend Forwardable
 
       include Tzispa::Helpers::Response
-      include Tzispa::Helpers::Security
       include Tzispa::Helpers::Session
 
       attr_reader    :request, :response
@@ -41,22 +39,6 @@ module Tzispa
         env['router.params'] || {}
       end
 
-      def layout
-        router_params&.fetch(:layout, nil)
-      end
-
-      def login_redirect
-        redirect(layout_path(config.login_layout.to_sym), true, response) if login_redirect?
-      end
-
-      def login_redirect?
-        !logged? && (layout != config.login_layout)
-      end
-
-      def unauthorized_but_logged
-        not_authorized unless logged?
-      end
-
       def path(path_id, params = {})
         app.routes.path path_id, params
       end
@@ -82,50 +64,12 @@ module Tzispa
         "#{canonical_root}#{app_path(app_name, path_id, params)}"
       end
 
-      def layout_path(layout, params = {})
-        is_default = app.default_layout? layout
-        params = normalize_format(params.merge(layout: layout)) unless is_default
-        app.routes.path layout, params
-      end
-
-      def app_layout_path(app_name, layout, params = {})
-        is_default = app[app_name].default_layout? == layout
-        params = normalize_format(params.merge(layout: layout)) unless is_default
-        app[app_name].routes.path layout, params
-      end
-
-      def layout_canonical_url(layout, params = {})
-        "#{canonical_root}#{layout_path(layout, params)}"
-      end
-
-      def app_layout_canonical_url(app_name, layout, params = {})
-        "#{canonical_root}#{app_layout_path(app_name, layout, params)}"
-      end
-
-      def api(handler, verb, predicate = nil, sufix = nil, app_name = nil)
-        if app_name
-          app_canonical_url app_name, :api, handler: handler, verb: verb,
-                                            predicate: predicate, sufix: sufix
-        else
-          canonical_url :api, handler: handler, verb: verb,
-                              predicate: predicate, sufix: sufix
-        end
-      end
-
-      def sapi(handler, verb, predicate = nil, sufix = nil, app_name = nil)
-        if app_name
-          sign = sign_array [handler, verb, predicate], app[:app_name].config.salt
-          app_canonical_url app_name, :sapi, sign: sign, handler: handler,
-                                             verb: verb, predicate: predicate, sufix: sufix
-        else
-          sign = sign_array [handler, verb, predicate], app.config.salt
-          canonical_url :sapi, sign: sign, handler: handler,
-                               verb: verb, predicate: predicate, sufix: sufix
-        end
+      def error_log(ex, status = nil)
+        logger.error "E [#{request.ip}] #{request.request_method} #{request.fullpath} #{status || response.status}\n#{ex.backtrace.first}: #{ex.message} (#{ex.class})\n#{ex.backtrace.drop(1).map { |s| "\t#{s}" }.join("\n") }"
       end
 
-      def path_sign?(sign, *args)
-        sign == sign_array(args, config.salt)
+      def info_log(ex, status = nil)
+        logger.info "I [#{request.ip}] #{request.request_method} #{request.fullpath} #{status || response.status}\n#{ex.backtrace.first}: #{ex.message} (#{ex.class})\n#{ex.backtrace.drop(1).map { |s| "\t#{s}" }.join("\n") }"
       end
 
       private

data/lib/tzispa/route_set.rb

@@ -14,11 +14,12 @@ module Tzispa
 
     attr_reader :router, :map_path, :app
 
-    def initialize(app, root = nil)
+    def initialize(app, root = nil, ctl_module = nil)
       @router = HttpRouter.new
       @app = app
       @router.default Controller::HttpError.new(app, :error_404)
       @map_path = root unless root == '/'
+      @ctl_module = ctl_module || CONTROLLERS_BASE
     end
 
     def setup
@@ -26,6 +27,7 @@ module Tzispa
         contents = File.read(routes_definitions)
         instance_eval(contents, File.basename(routes_definitions), 0)
       end
+      self
     end
 
     def routes_definitions
@@ -50,25 +52,10 @@ module Tzispa
       yield if block_given?
     end
 
-    def index(path, controller: nil, methods: nil)
-      add :index, path, controller || 'layout:render!', methods: methods
-    end
-
-    def api(path, controller: nil, methods: nil)
-      add :api, path, controller || 'api:dispatch!', methods: methods
-    end
-
-    def signed_api(path, controller: nil, methods: nil)
-      add :sapi, path, controller || 'api:dispatch!', methods: methods
-    end
-
-    def layout(layout, path, controller: nil, methods: nil)
-      add layout, path, controller || 'layout:render!', methods: methods,
-                                                        matching: { layout: layout.to_s }
-    end
-
     private
 
+    attr_reader :ctl_module
+
     def add_route(route_id, path, to:, methods: nil, matching: nil)
       @router.add(path).tap do |rule|
         rule.name = route_id
@@ -81,19 +68,23 @@ module Tzispa
     def build_controller(controller)
       spec_control, callmethod = controller.to_s.split(':')
       mpath = spec_control.split('#')
-      controller_class(mpath).new(app, callmethod)
+      if callmethod
+        controller_class(mpath).new(app, callmethod)
+      else
+        controller_class(mpath).new(app)
+      end
     end
 
     def controller_class(mpath)
       req_controller = mpath.pop
-      cmodule = if mpath.count > 1
-                  require "#{app.path}/controller/#{req_controller}"
-                  mpath.collect!(&:capitalize).join('::')
-                else
-                  require "tzispa/controller/#{req_controller}"
-                  CONTROLLERS_BASE
-                end
-      "#{cmodule}::#{req_controller.camelize}".constantize
+      cf_module = if mpath.count > 1
+                    require "#{app.path}/controller/#{req_controller}"
+                    mpath.collect!(&:capitalize).join('::')
+                  else
+                    require "#{ctl_module.underscore}/#{req_controller}"
+                    ctl_module
+                  end
+      "#{cf_module}::#{req_controller.camelize}".constantize
     end
   end
 

data/lib/tzispa/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Tzispa
-  VERSION = '0.7.6'
+  VERSION = '0.8.0'
   FRAMEWORK_NAME = 'Tzispa'
   GEM_NAME = 'tzispa'
 end

data/tzispa.gemspec

@@ -15,22 +15,22 @@ Gem::Specification.new do |s|
   s.description = 'A sparkling web framework Rack based'
   s.licenses    = ['MIT']
 
-  s.required_ruby_version = '~> 2.3'
+  s.required_ruby_version = '~> 2.4'
 
   s.add_dependency 'bundler',        '~> 1.14'
-  s.add_dependency 'rack',           '~> 2.0',    '>= 2.0.1'
+  s.add_dependency 'rack',           '~> 2.0', '>= 2.0.1'
   s.add_dependency 'i18n',           '~> 0.8.0'
   s.add_dependency 'thor',           '~> 0.19.0'
   s.add_dependency 'http_router',    '~> 0.11.2'
-  s.add_dependency 'tzispa_helpers', '~> 0.3'
+  s.add_dependency 'tzispa_helpers', '~> 0.3.4'
   s.add_dependency 'tzispa_utils',   '~> 0.3'
-  s.add_dependency 'tzispa_rig',     '~> 0.5'
+  s.add_dependency 'tzispa_rig',     '~> 0.5.8'
   s.add_dependency 'tzispa_data',    '~> 0.4'
   s.add_dependency 'dotenv',         '~> 2.2'
 
   s.add_development_dependency 'shotgun', '~> 0.9'
 
-  s.files         = Dir.glob('{lib,bin}/**/*') + %w(README.md CHANGELOG.md LICENSE tzispa.gemspec)
+  s.files         = Dir.glob('{lib,bin}/**/*') + %w[README.md CHANGELOG.md LICENSE tzispa.gemspec]
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.require_paths = ['lib']
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tzispa
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.8.0
 platform: ruby
 authors:
 - Juan Antonio Piñero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-17 00:00:00.000000000 Z
+date: 2017-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -92,14 +92,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 0.3.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 0.3.4
 - !ruby/object:Gem::Dependency
   name: tzispa_utils
   requirement: !ruby/object:Gem::Requirement
@@ -120,14 +120,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.8
 - !ruby/object:Gem::Dependency
   name: tzispa_data
   requirement: !ruby/object:Gem::Requirement
@@ -205,13 +205,17 @@ files:
 - lib/tzispa/config/db_config.rb
 - lib/tzispa/config/yaml.rb
 - lib/tzispa/context.rb
-- lib/tzispa/controller/api.rb
-- lib/tzispa/controller/auth_layout.rb
 - lib/tzispa/controller/base.rb
 - lib/tzispa/controller/exceptions.rb
+- lib/tzispa/controller/http.rb
 - lib/tzispa/controller/http_error.rb
-- lib/tzispa/controller/layout.rb
 - lib/tzispa/domain.rb
+- lib/tzispa/engine.rb
+- lib/tzispa/engine/rig/api.rb
+- lib/tzispa/engine/rig/auth_layout.rb
+- lib/tzispa/engine/rig/context.rb
+- lib/tzispa/engine/rig/layout.rb
+- lib/tzispa/engine/rig/router.rb
 - lib/tzispa/env.rb
 - lib/tzispa/environment.rb
 - lib/tzispa/http/context.rb
@@ -234,7 +238,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/tzispa/controller/api.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'tzispa/domain'
-require 'tzispa/controller/base'
-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::TzString
-
-      include Tzispa::Helpers::Response
-
-      def initialize(app, callmethod = :dispatch!)
-        super(app, callmethod, false)
-      end
-
-      def dispatch!
-        verb = context.router_params[:verb]
-        predicate = context.router_params[:predicate]
-        handler = prepare_handler
-        handler.run! verb, predicate
-        send(handler.type || :empty, handler)
-      end
-
-      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
-      end
-
-      def empty(handler)
-        api_response handler.status
-      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 = handler.data unless handler.error?
-        api_response handler.status, content, :htm
-      end
-
-      def json(handler)
-        content = handler.data.is_a?(::String) ? JSON.parse(handler.data) : handler.data.to_json        
-        api_response handler.status, content, :json
-      end
-
-      def text(handler)
-        content = handler.data unless handler.error?
-        api_response handler.status, content, :text
-      end
-
-      def download(handler)
-        send_file handler.data[:path], handler.data
-      end
-
-      def api_flash(message)
-        context.flash << message if config.sessions&.enabled
-      end
-
-      def api_response(status, content = nil, type = nil)
-        content_type(type) if type
-        response.body = content if content
-        response.status = status if status
-      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, request_method)
-          "#{domain.path}/api/#{request_method}/#{handler_name}.rb"
-        end
-
-        def handler_namespace(domain, request_method)
-          "#{domain.name.to_s.camelize}::Api::#{request_method.capitalize}"
-        end
-
-        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
-      end
-    end
-
-  end
-end

data/lib/tzispa/controller/auth_layout.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'tzispa/controller/layout'
-
-module Tzispa
-  module Controller
-
-    class AuthLayout < Layout
-      before :login_redirect
-    end
-
-  end
-end

data/lib/tzispa/controller/layout.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'tzispa_rig'
-require 'tzispa/controller/base'
-require 'tzispa/controller/exceptions'
-require 'tzispa/helpers/response'
-
-module Tzispa
-  module Controller
-    class Layout < Base
-      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
-        response.body << rig.render(context)
-        content_type rig.content_type
-      end
-
-      private
-
-      def layout_name
-        context.layout || config.default_layout
-      end
-    end
-
-  end
-end