tzispa 0.6.1 → 0.7.0

data/lib/tzispa/environment.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'pathname'
+require 'singleton'
+require 'tzispa/env'
+require 'tzispa/tzisparc'
+require 'tzispa/utils/hash'
+
+module Tzispa
+
+  class Environment
+    include Singleton
+    using Tzispa::Utils::TzHash
+
+    LOCK = Mutex.new
+
+    RACK_ENV = 'RACK_ENV'
+
+    TZISPA_ENV = 'TZISPA_ENV'
+
+    DEVELOPMENT_ENV = 'development'
+
+    DEFAULT_ENV = 'development'
+
+    PRODUCTION_ENV = 'deployment'
+
+    RACK_ENV_DEPLOYMENT = 'deployment'
+
+    DEFAULT_DOTENV_ENV = '.env.%s'
+
+    DEFAULT_CONFIG = 'config'
+
+    TZISPA_HOST = 'TZISPA_HOST'
+
+    TZISPA_SSL = 'TZISPA_SSL'
+
+    TZISPA_SERVER_HOST = 'TZISPA_SERVER_HOST'
+
+    DEFAULT_HOST = 'localhost'
+
+    TZISPA_PORT = 'TZISPA_PORT'
+
+    TZISPA_SERVER_PORT = 'TZISPA_SERVER_PORT'
+
+    DEFAULT_PORT = 9412
+
+    DEFAULT_RACKUP = 'tzispa.ru'
+
+    DEFAULT_ENVIRONMENT_CONFIG = 'environment'
+
+    DEFAULT_DOMAINS_PATH = 'apps'
+
+    DOMAINS = 'domains'
+
+    DOMAINS_PATH = 'apps/%s'
+
+    APPLICATION = 'application'
+
+    APPLICATION_PATH = 'app'
+
+    # rubocop:disable Style/ClassVars
+    @@opts = {}
+
+    def initialize
+      @env     = Tzispa::Env.new(env: @@opts.delete(:env) || ENV)
+      @options = Tzispa::Tzisparc.new(root).options
+      @options.merge! @@opts.clone.symbolize!
+      LOCK.synchronize { set_env_vars! }
+    end
+
+    def self.opts=(hash)
+      @@opts = hash.to_h.dup
+    end
+
+    def self.[](key)
+      instance[key]
+    end
+
+    def self.development?
+      instance.development?
+    end
+
+    def [](key)
+      @env[key]
+    end
+
+    def environment
+      @environment ||= env[TZISPA_ENV] || rack_env || DEFAULT_ENV
+    end
+
+    def development?
+      environment == DEVELOPMENT_ENV
+    end
+
+    def code_reloading?
+      development?
+    end
+
+    def environment?(*names)
+      names.map(&:to_s).include?(environment)
+    end
+
+    def bundler_groups
+      [:default, environment.to_sym]
+    end
+
+    def project_name
+      @options.fetch(:project)
+    end
+
+    def architecture
+      @options.fetch(:architecture) do
+        puts "Tzispa architecture unknown: see `.tzisparc'"
+        exit 1
+      end
+    end
+
+    def root
+      @root ||= Pathname.new(Dir.pwd)
+    end
+
+    def apps_path
+      @options.fetch(:path) do
+        case architecture
+        when DOMAINS
+          DOMAINS_PATH
+        when APPLICATION
+          APPLICATION_PATH
+        end
+      end
+    end
+
+    def config
+      @config ||= root.join(@options.fetch(:config) { DEFAULT_CONFIG })
+    end
+
+    def host
+      @host ||= @options.fetch(:host) do
+        env[TZISPA_HOST] || DEFAULT_HOST
+      end
+    end
+
+    def server_host
+      @server_host ||= @options.fetch(:server_host) do
+        env[TZISPA_SERVER_HOST] || host
+      end
+    end
+
+    def port
+      @port ||= @options.fetch(:port) do
+        env[TZISPA_PORT] || DEFAULT_PORT
+      end.to_i
+    end
+
+    def server_port
+      @server_port ||= @options.fetch(:server_port) do
+        env[TZISPA_SERVER_PORT] || port
+      end.to_i
+    end
+
+    def uri_port
+      if ssl?
+        ":#{port}" unless port == 443
+      else
+        ":#{port}" unless port == 80
+      end
+    end
+
+    def domains_path
+      @domains_path ||= @options.fetch(:domains_path) do
+        env[DOMAINS_PATH] || DEFAULT_DOMAINS_PATH
+      end
+    end
+
+    def default_port?
+      port == DEFAULT_PORT
+    end
+
+    def ssl?
+      env[TZISPA_SSL] == 'yes'
+    end
+
+    def rackup
+      root.join(@options.fetch(:rackup) { DEFAULT_RACKUP })
+    end
+
+    def daemonize?
+      @options.key?(:daemonize) && @options.fetch(:daemonize)
+    end
+
+    def to_options
+      @options.to_h.merge(
+        environment: environment,
+        apps_path:   apps_path,
+        rackup:      rackup,
+        host:        server_host,
+        port:        server_port
+      )
+    end
+
+    private
+
+    attr_reader :env
+
+    def set_env_vars!
+      set_application_env_vars!
+      set_tzispa_env_vars!
+    end
+
+    def set_tzispa_env_vars!
+      env[TZISPA_ENV]  = env[RACK_ENV] = environment
+      env[TZISPA_HOST] = host
+      env[TZISPA_PORT] = port.to_s
+    end
+
+    def set_application_env_vars!
+      dotenv = root.join(DEFAULT_DOTENV_ENV % environment)
+      env.load!(dotenv) if dotenv.exist?
+    end
+
+    def rack_env
+      case env[RACK_ENV]
+      when RACK_ENV_DEPLOYMENT
+        PRODUCTION_ENV
+      else
+        env[RACK_ENV]
+      end
+    end
+  end
+end

data/lib/tzispa/http/context.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'forwardable'
-require 'securerandom'
 require 'tzispa/context'
 require 'tzispa/http/response'
 require 'tzispa/http/request'
-require 'tzispa/http/session_flash_bag'
 require 'tzispa/helpers/response'
+require 'tzispa/helpers/session'
 require 'tzispa/helpers/security'
 
 module Tzispa
@@ -15,118 +16,111 @@ module Tzispa
 
       include Tzispa::Helpers::Response
       include Tzispa::Helpers::Security
+      include Tzispa::Helpers::Session
 
       attr_reader    :request, :response
       def_delegators :@request, :session
 
-      SESSION_LAST_ACCESS   = :__last_access
-      SESSION_ID            = :__session_id
-      SESSION_AUTH_USER     = :__auth__user
-      GLOBAL_MESSAGE_FLASH  = :__global_message_flash
-
+      def initialize(app, env)
+        super(app, env)
+        @request = Request.new(env)
+        @response = Response.new
+        init_session
+      end
 
-      def initialize(app, environment)
-        super(app, environment)
-        @request = Tzispa::Http::Request.new(environment)
-        @response = Tzispa::Http::Response.new
-        generate_session_id unless session[SESSION_ID]
+      def request_method
+        if request.request_method == 'POST' && request['_method']
+          env[Request::REQUEST_METHOD] = request['_method']
+          request['_method']
+        else
+          request.request_method
+        end
       end
 
       def router_params
-        env['router.params'] || Hash.new
+        env['router.params'] || {}
       end
 
       def layout
         router_params&.fetch(:layout, nil)
       end
 
-      def set_last_access
-        session[SESSION_LAST_ACCESS] = Time.now.utc.iso8601
-      end
-
-      def last_access
-        session[SESSION_LAST_ACCESS]
-      end
-
-      def flash
-        @flash ||= SessionFlashBag.new(session, GLOBAL_MESSAGE_FLASH)
-      end
-
-      def session?
-        (not session[SESSION_ID].nil?) and (session[SESSION_ID] == session.id)
-      end
-
-      def logged?
-        session? and (not session[SESSION_AUTH_USER].nil?)
-      end
-
-      def login=(user)
-        session[SESSION_AUTH_USER] = user unless user.nil?
-      end
-
-      def login
-        session[SESSION_AUTH_USER]
+      def login_redirect
+        redirect(layout_path(config.login_layout.to_sym), true, response) if login_redirect?
       end
 
-      def logout
-        session.delete(SESSION_AUTH_USER)
+      def login_redirect?
+        !logged? && (layout != config.login_layout)
       end
 
-      def error_500(str)
-        500.tap { |code|
-          response.body = str if str
-        }
+      def unauthorized_but_logged
+        not_authorized unless logged?
       end
 
-      def path(path_id, params={})
+      def path(path_id, params = {})
         app.routes.path path_id, params
       end
 
-      def app_path(app_name, path_id, params={})
+      def app_path(app_name, path_id, params = {})
         app[app_name].routes.path path_id, params
       end
 
-      def canonical_url(path_id, params={})
-        app.config.canonical_url + path(path_id, params)
+      def canonical_root
+        @canonical_root ||= begin
+          http_proto = Tzispa::Environment.instance.ssl? ? 'https://' : 'http://'
+          http_host = Tzispa::Environment.instance.host
+          http_port = Tzispa::Environment.instance.uri_port
+          "#{http_proto}#{http_host}#{http_port}"
+        end
       end
 
-      def app_canonical_url(app_name, path_id, params={})
-        app[app_name].config.canonical_url + app_path(app_name, path_id, params)
+      def canonical_url(path_id, params = {})
+        "#{canonical_root}#{path(path_id, params)}"
       end
 
-      def layout_path(layout, params={})
-        params = params.merge(layout: layout) unless app.config.default_layout&.to_sym == layout
-        app.routes.path layout, normalize_format(params)
+      def app_canonical_url(app_name, path_id, params = {})
+        "#{canonical_root}#{app_path(app_name, path_id, params)}"
       end
 
-      def app_layout_path(app_name, layout, params={})
-        params = params.merge(layout: layout) unless app[app_name].config.default_layout&.to_sym == layout
-        app[app_name].routes.path layout, normalize_format(params)
+      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 layout_canonical_url(layout, params={})
-        app.config.canonical_url + layout_path(layout, params)
+      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 app_layout_canonical_url(app_name, layout, params={})
-        app[app_name].config.canonical_url + app_layout_path(app_name, layout, params)
+      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, sufix, app_name = nil)
-        unless app_name
-          canonical_url :api, handler: handler, verb: verb, predicate: predicate, sufix: sufix
+        if app_name
+          app_canonical_url app_name, :api, handler: handler, verb: verb,
+                                            predicate: predicate, sufix: sufix
         else
-          app_canonical_url app_name, :api, handler: handler, verb: verb, predicate: predicate, sufix: sufix
+          canonical_url :api, handler: handler, verb: verb,
+                              predicate: predicate, sufix: sufix
         end
       end
 
       def sapi(handler, verb, predicate, sufix, app_name = nil)
-        unless app_name
-          sign = sign_array [handler, verb, predicate], app.config.salt
-          canonical_url :sapi, sign: sign, handler: handler, verb: verb, predicate: predicate, sufix: sufix
-        else
+        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
+          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
 
@@ -136,19 +130,10 @@ module Tzispa
 
       private
 
-      def generate_session_id
-        SecureRandom.uuid.tap { |uuid|
-          session.id = uuid
-          session[SESSION_ID] = uuid
-        }
-      end
-
       def normalize_format(params)
-        params.tap { |pmm|
-          pmm[:format] = config.default_format unless pmm[:format]
-        }
+        params.tap { |pmm| pmm[:format] = config.default_format unless pmm[:format] }
       end
-
     end
+
   end
 end

data/lib/tzispa/http/request.rb

@@ -2,34 +2,46 @@
 
 require 'rack'
 
-
 module Tzispa
   module Http
+
     class Request < Rack::Request
+      ALLOWED_HTTP_VERSIONS = ['HTTP/1.1', 'HTTP/2.0'].freeze
+
+      HTTP_X_FORWARDED_HOST = 'HTTP_X_FORWARDED_HOST'
 
-        alias secure? ssl?
+      REQUEST_METHOD = Rack::REQUEST_METHOD
 
+      alias secure? ssl?
 
-        def forwarded?
-          env.include? "HTTP_X_FORWARDED_HOST"
-        end
+      def forwarded?
+        env.include? HTTP_X_FORWARDED_HOST
+      end
 
-        def safe?
-          get? or head? or options? or trace?
-        end
+      def http_version
+        env['HTTP_VERSION']
+      end
 
-        def idempotent?
-          safe? or put? or delete? or link? or unlink?
-        end
+      def allowed_http_version?
+        ALLOWED_HTTP_VERSIONS.include? http_version
+      end
 
-        def link?
-          request_method == "LINK"
-        end
+      def safe?
+        get? || head? || options? || trace?
+      end
 
-        def unlink?
-          request_method == "UNLINK"
-        end
+      def idempotent?
+        safe? || put? || delete? || link? || unlink?
+      end
 
+      def link?
+        request_method == 'LINK'
+      end
+
+      def unlink?
+        request_method == 'UNLINK'
+      end
     end
+
   end
 end

data/lib/tzispa/http/response.rb

@@ -6,8 +6,7 @@ module Tzispa
   module Http
 
     class Response < Rack::Response
-
-      DROP_BODY_RESPONSES = [204, 205, 304]
+      DROP_BODY_RESPONSES = [204, 205, 304].freeze
 
       def initialize(*)
         super
@@ -15,8 +14,8 @@ module Tzispa
       end
 
       def body=(value)
-        value = value.body while Rack::Response === value
-        @body = String === value ? [value.to_str] : value
+        value = value.body while value.is_a?(Rack::Response)
+        @body = value.is_a?(String) ? [value.to_str] : value
       end
 
       def each
@@ -27,8 +26,8 @@ module Tzispa
         result = body
 
         if drop_content_info?
-          headers.delete "Content-Length"
-          headers.delete "Content-Type"
+          headers.delete 'Content-Length'
+          headers.delete 'Content-Type'
         end
 
         if drop_body?
@@ -39,27 +38,61 @@ module Tzispa
         if calculate_content_length?
           # if some other code has already set Content-Length, don't muck with it
           # currently, this would be the static file-handler
-          headers["Content-Length"] = body.inject(0) { |l, p| l + p.bytesize }.to_s
+          headers['Content-Length'] = body.inject(0) { |l, p| l + p.bytesize }.to_s
         end
-        headers['X-Frame-Options'] = 'SAMEORIGIN'
-        headers['X-Powered-By'] = "#{Tzispa::FRAMEWORK_NAME} #{Tzispa::VERSION}"        
+        custom_headers
         [status.to_i, headers, result]
       end
 
-      private
+      def custom_headers
+        headers['X-Frame-Options'] = 'SAMEORIGIN'
+        headers['X-Powered-By'] = "#{Tzispa::FRAMEWORK_NAME} #{Tzispa::VERSION}"
+      end
+
+      def cache_control
+        headers['Cache-control']
+      end
+
+      def cache_private
+        add_cache_control 'private'
+      end
+
+      def no_store
+        add_cache_control 'no-store'
+      end
+
+      def no_cache
+        add_cache_control 'no-cache'
+      end
+
+      def must_revalidate
+        add_cache_control 'must-revalidate'
+      end
+
+      def max_age(seconds)
+        add_cache_control "max-age=#{seconds}"
+      end
 
       def calculate_content_length?
-        headers["Content-Type"] and not headers["Content-Length"] and Array === body
+        headers['Content-Type'] && !headers['Content-Length'] && body.is_a?(Array)
       end
 
       def drop_content_info?
-        status.to_i / 100 == 1 or drop_body?
+        status.to_i / 100 == 1 || drop_body?
       end
 
       def drop_body?
         DROP_BODY_RESPONSES.include?(status.to_i)
       end
 
+      private
+
+      def add_cache_control(policy)
+        acache = (cache_control || String.new).split(',').map(&:strip)
+        acache << policy unless acache.include?(policy)
+        headers['Cache-control'] = acache.join(', ')
+        self
+      end
     end
 
   end