tzispa 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e7d9bdf85429d1bbe0fd303daff3853049aa4f6
-  data.tar.gz: 61aecb036fb1501b56572e8f5504ed9911e51242
+  metadata.gz: 494da0d1c9e0718fe00cf30c6ca12ff79656a152
+  data.tar.gz: b076698a91484ffee3f0561f4293034f5eea6115
 SHA512:
-  metadata.gz: 79493c3072124348bc1e9458615da7a75665c4a9ee6f29ef138ede3df6bdae48648402c7ecfb3058fc93357905717ed034f6e17b4f0929d18993603927981560
-  data.tar.gz: f38fabe97d6d006bfde4e0e2d9f2349d96a428c68f7fa818e38e33cb836b8f8a04257b7cd4137d06f69206e48c03f1d20610eba913411a61f2d45edf6081a435
+  metadata.gz: 98dd03475d556c2a0990b4f7979a4eba9ecc1ba94c8943874abf67a568c136f07fceb4c89de9672399bff13f7322d2f1a069a2d6693942be520b5d6816d00d4b
+  data.tar.gz: df7eb2126ea1cf8fc7bd2ddeefc8f975cf99c03d97ab90f31dd4cf5a3ba4d8e843e88ef56beac5bb66ed1d10252074b51ffff0e25a9ea4036e77d0d95a75aedb

data/CHANGELOG.md

@@ -2,6 +2,18 @@ Tzispa
 
 General purpose web framework
 
+## v0.7.0
+- distinct error and http status in api handlers
+- better api responses by content type
+- controller base: better error handling in invoke
+- api handlers: added support for api http verbs using request_method
+- independent db/repository configuration file
+- app environment implementation
+- automatic code reloading in development env (Shotgun)
+- added before hook in controllers and api-handlers
+- new routes specification file per app
+- code refactoring and bug fixes
+
 ## v0.6.1
 - sessions security improvements
 - added "x-frame-option: sameorigin" header to security improvement

data/lib/tzispa/api/handler.rb

@@ -19,69 +19,100 @@ module Tzispa
     class InvalidSign < ApiException; end
 
     class Handler
+      extend Forwardable
+
       include Tzispa::Helpers::Provider
       include Tzispa::Helpers::SignRequirer
-      extend Forwardable
 
-      using Tzispa::Utils
+      using Tzispa::Utils::TzString
 
-      attr_reader :context, :response_verb, :data, :status
-      def_delegators :@context, :request, :response, :app, :repository, :config, :logger
+      attr_reader :context, :type, :data, :error, :status
+      def_delegators :@context, :request, :response, :app, :repository,
+                     :config, :logger, :unauthorized_but_logged, :login_redirect
 
-      HANDLER_STATUS_UNDEFINED  = nil
-      HANDLER_STATUS_OK         = :ok
-      HANDLER_MISSING_PARAMETER = :missing_parameter
+      attr_writer :error
 
+      HANDLER_OK                = :ok
+      HANDLER_MISSING_PARAMETER = :missing_parameter
 
       def initialize(context)
         @context = context
+        @error = nil
+        @status = nil
       end
 
-      def result(response_verb:, data: nil, status: HANDLER_STATUS_UNDEFINED)
-        @response_verb = response_verb
-        @status = status if status
+      def result(type:, data: nil, error: nil)
+        @type = type
         @data = data
+        @error = error
+      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
 
       def error?
-        status && status != HANDLER_STATUS_OK
+        error && error != HANDLER_OK
+      end
+
+      def error_status(error, status = nil)
+        @error = error
+        @status = status
       end
 
-      def result_json(data, status: nil)
-        result response_verb: :json, data: data, status: status
+      def result_json(data, error: nil)
+        result type: :json, data: data, error: error
       end
 
-      def result_download(data, status: nil)
-        result response_verb: :download, data: data, status: status
+      def result_download(data, error: nil)
+        result type: :download, data: data, error: error
       end
 
       def not_found
-        result response_verb: :not_found
+        result type: :not_found
       end
 
       def message
-        I18n.t("#{self.class.name.dottize}.#{status}", default: "#{status}") if status
+        I18n.t("#{self.class.name.dottize}.#{error}", default: error.to_s) if error
       end
 
-      def run!(verb, predicate=nil)
+      def run!(verb, predicate = nil)
         raise UnknownHandlerVerb.new(verb, self.class.name) unless provides? verb
-        raise InvalidSign.new if sign_required? && !sign_valid?
+        raise InvalidSign if sign_required? && !sign_valid?
+        do_before
         # process compound predicates
         args = predicate ? predicate.split(',') : nil
         send verb, *args
       end
 
-      def set_status(value)
-        @status = value
+      def redirect_url(url)
+        if url && !url.strip.empty?
+          url.start_with?('#') ? "#{request.referer}#{url}" : url
+        else
+          request.referer
+        end
       end
 
       protected
 
       def static_path_sign?
-        context.path_sign? context.router_params[:sign], context.router_params[:handler], context.router_params[:verb], context.router_params[:predicate]
+        context.path_sign? context.router_params[:sign],
+                           context.router_params[:handler],
+                           context.router_params[:verb],
+                           context.router_params[:predicate]
       end
 
-
+      def do_before
+        self.class.before.each { |hbef| send hbef }
+      end
     end
+
   end
 end

data/lib/tzispa/app.rb

@@ -4,49 +4,37 @@ require 'forwardable'
 require 'logger'
 require 'i18n'
 require 'tzispa/domain'
-require 'tzispa/routes'
-require 'tzispa/config/appconfig'
-require 'tzispa/middleware'
+require 'tzispa/route_set'
+require 'tzispa/config/app_config'
+require 'tzispa/config/db_config'
 require 'tzispa_data'
 
-
 module Tzispa
 
-  ENV_TZISPA_APP     = :tzispa__app
-  ENV_TZISPA_CONTEXT = :tzispa__context
-
-
   class Application
     extend Forwardable
 
-    attr_reader :domain, :config, :middleware, :repository, :engine,
-                :logger, :mount_path, :routes
-
-    def_delegator :@middleware, :use
-    def_delegator :@domain, :name
-    def_delegators :@routes, :routing, :route_rig_index, :route_rig_api, :route_rig_signed_api, :route_rig_layout
+    attr_reader :domain, :logger, :map_path
 
+    def_delegators :@domain, :name, :path
+    def_delegators :@routes, :routing, :index, :api, :signed_api, :layout
 
     class << self
-
-      alias :__new__ :new
+      alias __new__ :new
 
       def new(*args, &block)
-        __new__(*args, &block).tap { |app|
-          add app
-        }
+        __new__(*args, &block).tap { |app| add app }
       end
 
+      # rubocop:disable Style/ClassVars
       def applications
         synchronize do
-          @@applications ||= Hash.new{ |hash, key| raise UnknownApplication.new("#{key}") }
+          @@applications ||= Hash.new { |_, key| raise UnknownApplication(key.to_s) }
         end
       end
 
       def synchronize
-        Mutex.new.synchronize {
-          yield
-        }
+        Mutex.new.synchronize { yield }
       end
 
       def [](name)
@@ -55,78 +43,82 @@ module Tzispa
 
       def add(app)
         synchronize do
-          raise DuplicateDomain.new("You have try to add an app with a duplicate domain name #{app.name}") if applications.has_key? app.name
+          raise DuplicateDomain.new(app.name) if applications.key?(app.name)
           applications[app.name] = app
         end
       end
-
-      def run(appid, builder: nil, on: nil, &block)
-        theapp = self.new appid, on: on, &block
-        theapp.run builder
-      end
-
     end
 
     def initialize(appid, on: nil, &block)
       @domain = Domain.new(appid)
-      @config = Config::AppConfig.new(@domain).load!
-      @middleware = Middleware.new self
-      @routes ||= Routes.new(self, on)
+      @map_path = on
       instance_eval(&block) if block
     end
 
-    def run(builder=nil)
-      builder ||= ::Rack::Builder.new
-      if routes.map_path
-        this_app = self
-        builder.map routes.map_path do
-          run this_app.middleware.builder
-        end
-      else
-        builder.run middleware.builder
-      end
+    def call(env)
+      routes.call env
     end
 
     def load!
-      self.class.synchronize {
-        load_locales
-        @logger = Logger.new("logs/#{domain.name}.log", config.logging.shift_age).tap { |log|
-          log.level = config.developing ? Logger::DEBUG : Logger::INFO
-        } if config.logging&.enabled
-        domain_setup
-        @repository = Data::Repository.new(config.repository.to_h).load!(domain) if config.respond_to? :repository
-        @loaded = true
-      }
-      self
+      tap do |app|
+        app.class.synchronize do
+          logging
+          load_locales
+          domain.setup
+          routes.setup
+          repository&.load!(domain)
+        end
+      end
     end
 
     def [](domain)
       self.class[domain]
     end
 
-    private
+    def default_layout?(layout)
+      config.default_layout.to_sym == layout
+    end
 
-    def domain_setup
-      domain.require_dir
-      domain.require_dir 'helpers'
-      domain.require_dir 'services'
-      domain.require_dir 'api'
-      domain.require_dir 'middleware'
+    def env
+      Tzispa::Environment.instance
     end
 
-    def load_locales
-      if config.respond_to?(:locales)
-        I18n.enforce_available_locales = false
-        I18n.load_path += Dir["config/locales/*.yml", "#{domain.path}/locales/*.yml"]
+    def routes
+      @routes ||= RouteSet.new(self, map_path)
+    end
+
+    def config
+      @config ||= Config::AppConfig.new(@domain).load!
+    end
+
+    def repository
+      @repository ||= begin
+        dbcfg = Config::DbConfig.new(env.environment)&.to_h
+        Data::Repository.new(dbcfg) if dbcfg&.count&.positive?
       end
     end
 
-    public
+    private
 
-    class ApplicationError < StandardError; end
-    class UnknownApplication < ApplicationError; end
-    class DuplicateDomain < ApplicationError; end
+    def logging
+      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
+      return unless config.respond_to?(:locales)
+      I18n.enforce_available_locales = false
+      I18n.load_path += Dir['config/locales/*.yml', "#{domain.path}/locales/*.yml"]
+    end
+  end
 
+  class ApplicationError < StandardError; end
+  class UnknownApplication < ApplicationError; end
+  class DuplicateDomain < ApplicationError
+    def initialize(app_name)
+      super "You have tried to add an app with a duplicate domain name #{app_name}"
+    end
   end
+
 end

data/lib/tzispa/cli.rb

@@ -1,18 +1,57 @@
+# frozen_string_literal: true
+
 require 'thor'
+require 'tzispa'
 
 module Tzispa
 
   class Cli < Thor
-
     desc 'version', 'Prints Tzispa version'
     def version
       require 'tzispa/version'
       puts "v#{VERSION}"
     end
 
-    require 'tzispa/command/cli/generate'
-    register Tzispa::Command::Cli::Generate, 'generate', 'generate [SUBCOMMAND]', 'Generate Tzispa components'
+    desc 'new', 'Generate a new Tzispa project'
+    def new(name)
+      require 'tzispa/commands/project'
+      Tzispa::Commands::Project.new(name).generate
+      puts "Project '#{name}' has been created"
+    end
+
+    require 'tzispa/commands/server'
+    desc 'server', 'Start Tzispa app server'
+    method_option :port, aliases: '-p', desc: 'The port to run the server on'
+    method_option :server, desc: 'Choose a specific Rack::Handler (webrick, thin, etc)'
+    method_option :rackup, desc: 'A rackup configuration file path to load (config.ru)'
+    method_option :host, desc: 'The host address to bind to'
+    method_option :debug, desc: 'Turn on debug output'
+    method_option :warn, desc: 'Turn on warnings'
+    method_option :daemonize, desc: 'If true, the server will daemonize itself'
+    method_option :help, desc: 'Displays the help usage'
+    def server
+      if options[:help]
+        invoke :help, ['server']
+      else
+        Tzispa::Commands::Server.new(options).start
+      end
+    end
+
+    require 'tzispa/commands/console'
+    desc 'console', 'Starts a Tzispa console'
+    method_option :engine, desc: "Choose: (#{Tzispa::Commands::Console::ENGINES.keys.join('/')})"
+    method_option :help, desc: 'Displays the usage help'
+    def console
+      if options[:help]
+        invoke :help, ['console']
+      else
+        Tzispa::Commands::Console.new(options).start
+      end
+    end
 
+    require 'tzispa/commands/cli/generate'
+    register Tzispa::Commands::Cli::Generate, 'generate', 'generate [SUBCOMMAND]',
+             'Generate Tzispa components'
   end
 
 end

data/lib/tzispa/commands/api.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tzispa/controller/api'
+require 'tzispa/commands/command'
+require 'tzispa/utils/indenter'
+
+module Tzispa
+  module Commands
+
+    class Api < Command
+      attr_reader :name, :domain, :verb
+
+      def initialize(name, app, verb, options = nil)
+        super(options)
+        @domain = Tzispa::Domain.new app
+        @name = name
+        @verb = verb
+      end
+
+      def generate
+        file_name = Tzispa::Controller::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)
+        create_file file_name, namespace, class_name
+      end
+
+      private
+
+      def create_file(file_name, ns, class_name)
+        dir, = Pathname.new(file_name).split
+        FileUtils.mkpath dir
+        File.open(file_name, 'w') do |f|
+          f.puts handler_code(ns, class_name)
+        end
+      end
+
+      def handler_code(namespace, class_name)
+        Tzispa::Utils::Indenter.new.tap do |code|
+          code << "require 'tzispa/api/handler'\n\n"
+          level = 0
+          namespace.split('::').each do |ns|
+            level.positive? ? code.indent << "module #{ns}\n" : code << "module #{ns}\n"
+            level += 1
+          end
+          code.indent << "\nclass #{class_name} < Tzispa::Api::Handler\n\n"
+          code << "end\n\n"
+          namespace.split('::').each { code.unindent << "end\n" }
+        end.to_s
+      end
+    end
+
+  end
+end

data/lib/tzispa/commands/app.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tzispa/domain'
+require 'tzispa/utils/string'
+require 'tzispa/utils/indenter'
+require 'tzispa/config/app_config'
+require 'tzispa/commands/command'
+
+module Tzispa
+  module Commands
+    class App < Command
+      using Tzispa::Utils::TzString
+
+      APP_STRUCTURE = [
+        'api', 'locales', 'error', 'controller', 'helpers', 'view', 'view/_',
+        'view/_/block', 'view/_/layout', 'view/_/static', 'services'
+      ].freeze
+
+      attr_reader :domain
+
+      def initialize(name, options = nil)
+        super(options)
+        @domain = Tzispa::Domain.new(name)
+      end
+
+      def generate(mount_path, index_layout, locale)
+        update_rackup mount_path
+        create_structure
+        create_appconfig index_layout, locale
+        create_home_layout
+        create_routes
+      end
+
+      private
+
+      def update_rackup(mount_path = nil)
+        mount_path ||= DEFAULT_MOUNT_PATH
+        File.open(Tzispa::Environment::DEFAULT_RACKUP, 'a') do |f|
+          f.puts write_app_code(mount_path)
+        end
+      end
+
+      def write_app_code(mount_path)
+        map_path = mount_path.start_with?('/') ? mount_path : "/#{mount_path}"
+        Tzispa::Utils::Indenter.new(2).tap do |code|
+          code << "\nmap '#{map_path}' do\n"
+          code.indent << "run Tzispa::Application.new(:#{domain.name},on: '#{map_path}').load!\n"
+          code.unindent << "end\n"
+        end.to_s
+      end
+
+      def create_structure
+        return unless File.exist? domain.path
+        Dir.mkdir domain.path.to_s
+        APP_STRUCTURE.each { |appdir| Dir.mkdir "#{domain.path}/#{appdir}" }
+      end
+
+      def create_appconfig(default_layout, locale)
+        appconfig = Tzispa::Config::AppConfig.new(domain)
+        @config = appconfig.create_default(default_layout, locale)
+      end
+
+      def create_home_layout
+        tpl = Tzispa::Rig::Template.new(name: @config.default_layout || 'index',
+                                        type: :layout,
+                                        domain: domain,
+                                        content_type: :htm)
+        tpl.create("<html><body><h1>Welcome: #{domain.name} is working!</h1></body></html>")
+      end
+
+      def create_routes
+        File.open("config/routes/#{domain.name}.rb", 'w') do |file|
+          file.puts '# app routes definitions \n'
+          file.puts "index       '/', controller: 'layout:render!'"
+          file.puts "signed_api  '/api_:sign/:handler/:verb(~:predicate)(/:sufix)'"
+          file.puts "api         '/api/:handler/:verb(~:predicate)(/:sufix)'"
+        end
+      end
+    end
+
+  end
+end

data/lib/tzispa/commands/cli/generate.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Tzispa
+  module Commands
+    module Cli
+
+      class Generate < Thor
+        require 'tzispa/commands/app'
+        desc 'app', 'Generate new application into a project'
+        method_option :mount, aliases: '-m', desc: 'The mount point for this app', default: '/'
+        method_option :index, aliases: '-i', desc: 'Default index layout', default: 'index'
+        method_option :locale, aliases: '-l', desc: 'Default app locale', default: 'en'
+        def app(name)
+          tzapp = Tzispa::Commands::App.new(name)
+          tzapp.generate(options[:mount], options[:index], options[:locale])
+          puts "App '#{name}' has been created"
+        end
+
+        require 'tzispa/commands/rig'
+        desc 'rig', 'Generate new rig template'
+        method_option :app, aliases: '-a',
+                            desc: 'The app where create the new template', required: true
+        method_option :type, aliases: '-t',
+                             desc: 'Template type: block, static or layout', required: true
+        def rig(name)
+          tpl = Tzispa::Commands::Rig.new(name, options[:app], options[:type])
+          tpl.generate
+          puts "Rig #{options[:type]} template '#{name}' has been created in #{options[:app]}"
+        end
+
+        require 'tzispa/commands/repository'
+        desc 'repository', 'Generate new repsitory'
+        method_option :adapter, aliases: '-a',
+                                desc: 'Database adapter to use in the repository', required: true
+        method_option :database, aliases: '-d',
+                                 desc: 'Database connection string or path', required: true
+        def repository(name)
+          repo = Tzispa::Commands::Repository.new name, options[:adapter], options[:database]
+          repo.generate
+          puts "Repository #{name} has been created into local project"
+        end
+
+        require 'tzispa/commands/api'
+        desc 'api', 'Generate new api handler'
+        method_option :app, aliases: '-a',
+                            desc: 'The app where the api handler will be created', required: true
+        method_option :verb, aliases: '-v',
+                             desc: 'The http verb that this api will respond to', required: true
+        def api(name)
+          hnd = Tzispa::Commands::Api.new(name, options[:app], options[:verb])
+          hnd.generate
+          puts "Api handler '#{name}' has been created in #{options[:app]}"
+        end
+      end
+
+    end
+  end
+end

data/lib/tzispa/commands/command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'tzispa/environment'
+
+module Tzispa
+  module Commands
+
+    class Command
+
+      NO_PROJECT_FOLDER = 'You must be located in a Tzispa project folder to run this command'
+
+      def initialize(options)
+        raise NO_PROJECT_FOLDER unless project_folder?
+        Tzispa::Environment.opts = options
+        @environment = Tzispa::Environment.instance
+      end
+
+      protected
+
+      attr_reader :environment
+
+      def project_folder?
+        File.exist?(Tzispa::Environment::DEFAULT_RACKUP)
+      end
+    end
+
+  end
+end