nekonote-framework 1.0.0.pre.beta

data/lib/nekonote/cmd_parser.rb

@@ -0,0 +1,55 @@
+module Nekonote
+    class CmdParser
+        # @param array argv
+        public
+        def initialize(argv)
+            @argv = argv
+        end
+
+        # @return bool
+        public
+        def version_option?
+            return @argv.index('-v') || @argv.index('--version')
+        end
+
+        # @return bool
+        public
+        def help_option?
+            return @argv.index('-h') || @argv.index('--help')
+        end
+
+        # @return bool
+        public
+        def root_option?
+            return @argv.index '--root'
+        end
+
+        # @return nil|mixed
+        public
+        def get_op_val_root
+            index = @argv.index '--root'
+            return nil if index == nil
+            return @argv[index+1]
+        end
+
+        # @return cmd, subcmd, val
+        public
+        def parse_un_options
+            argv = @argv.clone
+
+            # delete options
+            index = argv.index '--root'
+            if index != nil
+                argv.delete_at(index+1) if argv[index+1] != nil
+                argv.delete_at index
+            end
+
+            # untaint
+            argv.map! do |v|
+                v.intern.to_s if v.is_a? String
+            end
+
+            return *argv
+        end
+    end
+end

data/lib/nekonote/core.rb

@@ -0,0 +1,116 @@
+module Nekonote
+    @@env ||= ENV['NEKONOTE_ENV']
+    @@root                   = nil
+    @@root_path              = nil
+    @@logger_enabled         = nil
+    @@logger_write_exception = nil
+
+    # set root directory to the application
+    # @param string root
+    def self.set_root(root)
+        if root.is_a?(String) && @@root != ''
+            root      = File.expand_path root
+            root_path = root + '/'
+            @@root      ||= root
+            @@root_path ||= root_path
+        else
+            # root is empty
+            raise Error, Error::MSG_MISSING_ROOT
+        end
+
+        # root exist?
+        if !Util::Filer.available_dir? @@root
+            raise Error, Error::MSG_MISSING_DIR% @@root
+        end
+
+        # config.ru exist?
+        if !Util::Filer.available_file? @@root_path + 'config.ru'
+            msg  = Error::MSG_MISSING_RACKUP% @@root_path + $/
+            msg += Error::SPACE + Error::MSG_WRONG_ROOT
+            raise Error, msg
+        end
+    end
+
+    # @return string
+    def self.get_env
+        if !has_valid_env?
+            raise Error, Error::MSG_MISSING_ENV
+        end
+        return @@env
+    end
+
+    # @return bool
+    def self.has_valid_env?
+        return @@env.is_a?(String) && @@env != '' && @@env.match('/') == nil && @@env.match('\*') == nil
+    end
+
+    # @return string
+    def self.get_root
+        if @@root == nil
+            raise Error, Error::MSG_NOT_DEFINED_ROOT
+        end
+        return @@root
+    end
+
+    # @return string
+    def self.get_root_path
+        if @@root_path == nil
+            raise Error, Error::MSG_NOT_DEFINED_ROOT
+        end
+        return @@root_path
+    end
+
+    # @return bool
+    def self.has_root?
+        return @@root != nil
+    end
+
+    # @return bool
+    def self.from_cli?
+        return defined?(@@from_cli) && @@from_cli
+    end
+
+    # logger is enabled or not?
+    # @return bool
+    def self.logger_enabled?
+        return @@logger_enabled
+    end
+
+    # @return bool
+    def self.need_logging_exception?
+        return logger_enabled? && @@logger_write_exception
+    end
+
+    # load and initialize logger if it has been enabled
+    def self.init_logger
+        pref_logger = Preference.instance.get_logger true # don't use property cache
+
+        if pref_logger['write_exception'] == true
+            @@logger_write_exception = true
+        else
+            @@logger_write_exception = false
+        end
+
+        if pref_logger['enabled'] == true
+            # the method for logger will be defined
+            Logger.instance.init pref_logger
+            @@logger_enabled = true
+        else
+            # remove the defined method for logging
+            if Object.respond_to? :logwrite, true
+                Object.class_eval { remove_method :logwrite }
+            end
+            @@logger_enabled = false
+        end
+    end
+
+    # load base handler from app root
+    def self.load_base_handler
+        begin
+            require get_root_path + 'handler/base'
+
+        rescue LoadError
+            raise LoadError, Error::MSG_MISSING_FILE% path
+        end
+    end
+end

data/lib/nekonote/env.rb

@@ -0,0 +1,56 @@
+module Nekonote
+    class Env
+        private_class_method :new
+        @rackenv = {}
+
+        # Get values in a specified field
+        # @param string|synbol|nil field
+        # @return mixed|nil in the case of that missing specified key or missing fields will return nil
+        def self.get(field = nil)
+            return nil if field == nil
+
+            if !field.is_a? String
+                field = field.to_s
+            end
+
+            field.strip!
+            return '' if field == ''
+
+            return @rackenv[field]
+        end
+
+        # Get the whole environments
+        # @return hash
+        def self.get_all
+            return @rackenv
+        end
+
+        # @return string
+        def self.current
+            return Nekonote.get_env
+        end
+
+        # @return string
+        def self.root
+            return Nekonote.get_root
+        end
+
+        # @return string
+        def self.root_path
+            return Nekonote.get_root_path
+        end
+
+        # @return array|nil
+        def self.keys
+            if @rackenv.is_a? Hash
+                return @rackenv.keys
+            end
+            return nil
+        end
+
+        # @param hash rackenv
+        def self.set_rackenv(rackenv)
+            @rackenv = rackenv
+        end
+    end
+end

data/lib/nekonote/exception/cli_error.rb

@@ -0,0 +1,34 @@
+module Nekonote
+    class CLIError < Error
+        MSG_PERMIT_MAKE_DIR = %{Failed to generate an application structure in '%s' because of invalid permission or not found.}
+        MSG_UNABLE_TO_LOAD  = %(Unable to load %s. Did you really install it?)
+
+        MSG_MISSING_AFTER_NEW     = %(Please set something after new.)
+        MSG_MISSING_NEW_PATH      = %(Please set some name to generate.)
+        MSG_MISSING_STRUCTURE_DIR = %(The specified directory was not found. Please make sure '%s' directory exists on your server.)
+        MSG_MISSING_DEST_PATH     = %('%s' was not found in the application structure.)
+        MSG_MISSING_AFTER_SERVER  = %('nekonote server' requires some sub-command.)
+
+        MSG_INVALID_NEW_NAME      = %(Invalid name '%s'.)
+        MSG_INVALID_HANDLER_NAME  = %(Invalid handler name '%s'.)
+        MSG_INVALID_TEMPLATE_NAME = %(Invalid template name '%s'.)
+        MSG_INVALID_LAYOUT_NAME   = %(Invalid layout name '%s'.)
+        MSG_INVALID_ENV_NAME      = %(Invalid environment name '%s'.)
+
+        MSG_ALREADY_EXISTS_APP      = %('%s' exists already. You need to remove it at first.)
+        MSG_ALREADY_EXISTS_HANDLER  = %(Handler '%s' exists already. Nothing to do.)
+        MSG_ALREADY_EXISTS_TEMPLATE = %(Template '%s' exists already. Nothing to do.)
+        MSG_ALREADY_EXISTS_LAYOUT   = %(Layout '%s' exists already. Nothing to do.)
+        MSG_ALREADY_EXISTS_ENV      = %(Environment '%s' exists already. Nothing to do.)
+
+        MSG_FAILED_CREATE_HANDLER  = %(Failed to create a handler by the following reason '%s')
+        MSG_FAILED_CREATE_TEMPLATE = %(Failed to create a template by the following reason '%s')
+        MSG_FAILED_CREATE_LAYOUT   = %(Failed to create a layout by the following reason '%s')
+        MSG_FAILED_GEN_DIR_BY_FILE = %(Failed to create a directory '%s'. There is the file which the same name.)
+        MSG_FAILED_START_SERVER    = %(Failed to start the web server. Please check the error message.)
+
+        MSG_UNKNOWN_AFTER_NEW    = %(Unknown sub command 'nekonote new %s'.)
+        MSG_UNKNOWN_AFTER_SERVER = %(Unknown sub command 'nekonote server %s'.)
+        MSG_UNKNOWN_SUB_COMMAND  = %(Unknown sub command '%s'. Typing 'nekonote -h' will help you.)
+    end
+end

data/lib/nekonote/exception/error.rb

@@ -0,0 +1,75 @@
+module Nekonote
+    # static methods class
+    class Error < StandardError
+        SPACE = '    '
+        MSG_MISSING_ENV          = %(Environment variable NEKONOTE_ENV is empty or invalid environment name is set.)
+        MSG_MISSING_ROOT         = %(Missing root directory to the application structure.)
+        MSG_NOT_DEFINED_ROOT     = %(Application root is not defined yet.)
+        MSG_MISSING_FILE         = %(No such file '%s' or can't read it.)
+        MSG_MISSING_DIR          = %(No such directory '%s' or can't read it.)
+        MSG_MISSING_RACKUP       = %(Missing config.ru under '%s' or can't read it.)
+        MSG_LACK_FIELD_IN_YAML   = %(Lack of the required field '%s'. Please check if '%s' is set properly.)
+        MSG_EMPTY_YAML           = %('%s' is empty. You must configure something.)
+        MSG_WRONG_ROOT           = %(You'd better run the command at the application root, or --root option will solve the problem.)
+        MSG_WRONG_TYPE           = %(You gave %s but the expected type is '%s'.)
+        MSG_MISSING_FIELD        = %(The required field '%s' was not found in '%s'.)
+        MSG_INVALID_FIELD        = %(Invalid format field '%s' in '%s'.)
+        MSG_MISSING_CONST        = %(Missing such class or module or contant -> '%s'.)
+        MSG_EMPTY_FILE_NOT_EMPTY = %('%s' is not empty. Failed to create an empty file.)
+
+        # write message as warning to log file if logging is enabled
+        # @param string msg
+        def self.warning(msg)
+            logging_warn msg
+
+            begin
+                if Nekonote.from_cli?
+                    warn 'Warning: ' + msg
+                end
+            rescue
+            end
+        end
+
+        # @param StandardError e
+        def self.abort(e)
+            logging_error e
+
+            # if executed from cli do not throw exception
+            if Nekonote.from_cli?
+                warn "#{e.class}; =(-x-=;)" + $/
+                warn SPACE + e.message + $/ + $/
+                if !e.is_a? Nekonote::Error
+                    warn e.backtrace
+                end
+                exit 1
+            end
+
+            raise e
+        end
+
+        # write error informaton to log file if logging is enabled
+        # @param string msg
+        def self.logging_warn(msg)
+            begin
+                if Nekonote.need_logging_exception?
+                    logwrite msg, Nekonote::Logger::WARN
+                    Nekonote::Logger.instance.set_level_default
+                end
+            rescue
+            end
+        end
+
+        # write error informaton to log file if logging is enabled
+        # @param StandardError e
+        def self.logging_error(e)
+            begin
+                if Nekonote.need_logging_exception?
+                    msg = %(#{e.class} - #{e.message}) + $/ + e.backtrace.join($/)
+                    logwrite msg, Nekonote::Logger::FATAL
+                    Nekonote::Logger.instance.set_level_default
+                end
+            rescue
+            end
+        end
+    end
+end

data/lib/nekonote/exception/handler_error.rb

@@ -0,0 +1,5 @@
+module Nekonote
+    class HandlerError < Error
+        MSG_MISSING_ERR_HANDLER = 'No Handler in route_error.yml.';
+    end
+end

data/lib/nekonote/exception/logger_error.rb

@@ -0,0 +1,8 @@
+module Nekonote
+    class LoggerError < Error
+        MSG_MISSING_LOGFILE     = %(Lack of the required directives 'logfile' and 'keep' and 'limit' in logger.yml.)
+        MSG_FAILED_INITIALIZE   = %(Failed to initialize logger. Wrong syntax in logger.yml or '%s' doesn't have a permission to create '%s'.)
+        MSG_FAILED_DEF_OPT      = %(Failed to define optional value. Maybe there is wrong syntax in logger.yml. Please check the reference manual.)
+        MSG_UNDIFINED_LOG_LEVEL = %(Undifined log level was given. Please check the reference manual.)
+    end
+end

data/lib/nekonote/exception/page_cache_error.rb

@@ -0,0 +1,6 @@
+module Nekonote
+    class PageCacheError < Error
+        MSG_THERE_IS_DIRECTORY      = %(There is the unknown directory under the 'cache' directory.) 
+        MSG_CHACHE_DIR_WRONG_PERMIT = %(Wrong permission or the cache directory '%s' was not found.)
+    end
+end

data/lib/nekonote/exception/preference_error.rb

@@ -0,0 +1,11 @@
+module Nekonote
+    class PreferenceError < Error
+        MSG_UNDEFINED_FIELD      = %(Undefined field '%s'.)
+        MSG_WRONG_YAML_SYNTAX    = %(The yaml file '%s' is invalid syntax.)
+        MSG_MISSING_INCLUDE      = %(No such field '%s' in %s.)
+        MSG_INVALID_HANDLER_NAME = %(Handler class name '%s' is invalid.)
+        MSG_NO_SUCH_HANDLER      = %(No such handler class '%s'. You must make it at first.)
+        MSG_DUPLICATE_PATH       = %(There is the duplicate path in %s. Values of 'path' directive are supposed to be uniq.)
+        MSG_EVAL_MIDDLEWARES     = %(Unable to evaluate '%s' because there's something wrong.)
+    end
+end

data/lib/nekonote/exception/view_error.rb

@@ -0,0 +1,7 @@
+module Nekonote
+    class ViewError < Error
+        MSG_MISSING_TEMPLATE_FILE = %(Failed to load the tempalte file. No such file '%s')
+        MSG_MISSING_LAYOUT_FILE   = %(Failed to load the layout file. No such file '%s')
+        MSG_FAILED_TO_ASSIGN      = %(Failed to assign variables into templates. You gave wrong type. The expected type is Hash.)
+    end
+end

data/lib/nekonote/handler.rb

@@ -0,0 +1,274 @@
+module Nekonote
+    class Handler
+        EXIT = 'Nekonote exit from queue'
+        require Nekonote.get_lib_root_path + 'handler/protected_methods'
+        include ProtectedMethods
+
+        # =============================================
+        # Accessors
+        # =============================================
+        attr_accessor :route_regexp,
+                      :url_path_params_mapper
+
+        # =============================================
+        # Static method
+        # =============================================
+        # make error handler and execute it
+        # @param string field
+        # @param hash env
+        # @param nil e
+        # @return array
+        def self.call_error_handler(field, env = {}, e = nil)
+            pref = Preference.instance.get_route_error
+
+            # field is expected String and pref[field] is expected Hash
+            if !field.is_a?(String) || !pref[field].is_a?(Hash)
+                raise HandlerError, HandlerError::MSG_MISSING_FIELD%[field, Preference.instance.path_route_error_yml]
+            end
+
+            # make handler newly
+            handler_name = pref[field][Preference::FIELD_ROUTE_HANDLER]
+            if handler_name.is_a? String
+                begin
+                    handler_class = Object.const_get handler_name
+                    error_handler = handler_class.new pref[field].clone, field, e
+                rescue
+                    raise HandlerError, HandlerError::MSG_MISSING_CONST% handler_name
+                end
+            else
+                raise HandlerError, HandlerError::MSG_MISSING_ERR_HANDLER
+            end
+
+            return error_handler.call env
+        end
+
+
+        # It would be called only one time
+        # @param hash info route information
+        # @param bool|nil error_field_name
+        # @param StandardError error
+        def initialize(info={}, error_field_name = nil, error = nil)
+            # Both the properties are allowed to access in sub classes
+            @view = View.new (info || {}), self.class.to_s, error_field_name
+
+            @request      = nil # Object of Nekonote::Request
+            @session      = nil # Object about session management
+            @route_regexp = nil # Object of Regexp
+            @url_path_params_mapper = nil # Hash
+
+            # exception object will be set if fatal error occured
+            @error = error
+
+            # custom fields will be set, if no custom field just {} will be set
+            @custom_fields = Preference.get_custom_fields info, error_field_name.is_a?(String)
+        end
+
+        # reload preferences
+        private
+        def pref_reloader
+            path = Nekonote.get_root_path + Preference::FILE_NAME_FOR_RELOAD
+            if File.exist? path
+                # reload logger
+                Nekonote.init_logger
+
+                # reload setting
+                Setting.init
+
+                Util::Filer::safe_delete_empty_file path
+            end
+        end
+
+        # This method would be called from rack and called in every request
+        # @param hash env rack environment
+        public
+        def call(env)
+            # reload preferences if needed
+            pref_reloader
+
+            # get reponse data from page cache if it's available
+            if @view.can_get_from_page_cache?(env['REQUEST_URI'])
+                response_data = @view.get_response_data_from_page_cache env['REQUEST_URI']
+                if response_data.size == 3
+                    # return the cache
+                    return response_data
+                else
+                    # invalid page cache file, put warning message
+                    Error.warning 'Wrong page cache file was detected. Please remove page cache.'
+                end
+            end
+
+            # initialize response
+            @view.init_for_response
+
+            # set env to Nekonote::env
+            Env.set_rackenv env
+
+            # set session if it's enabled
+            @session = Env.get 'rack.session'
+
+            # set request
+            @request = Request.new env, @view.info_params
+
+            # set request body to request object if it exists
+            if env['rack.input'].is_a? StringIO
+                # reverting file pointer I don't know why the pointer moved just one...?
+                env['rack.input'].rewind
+                @request.set_payload env['rack.input'].read
+            end
+
+            # execute
+            if !@view.is_error_route
+                begin
+                    return execute env
+
+                rescue StandardError, ScriptError => e
+                    # fatal error occured
+                    process_exception_raised e
+
+                    # if ShowExceptions is disabled and fatal error route has been defined, forward custom error page
+                    if Preference.instance.has_error_route? Preference::FIELD_ROUTE_ERR_FATAL
+                        return Handler.call_error_handler Preference::FIELD_ROUTE_ERR_FATAL, Env.get_all, e
+                    end
+                end
+
+            else
+                # If self is Handler for error routes
+                begin
+                    execute_handler_methods @view.info_exec_method
+                    return get_response_data
+
+                rescue StandardError, ScriptError => e
+                    process_exception_raised e
+                end
+            end
+
+            # in the case of an exception raised but
+            # there is no fatal error route OR the exception raised in fatal error route
+            # and also ShowExceptons does not handle an exception
+            # returns an empty response
+            # TODO Do I have to change them to be customizable?
+            return View.get_default_error_response
+        end
+
+        # @param StandardError|ScriptError e
+        # @throws StandardError|ScriptError
+        private
+        def process_exception_raised(e)
+            # logging if logger is enabled
+            Error.logging_error e
+
+            # raise the exception for ShowExceptions if it's enabled
+            raise e if Preference.instance.is_enabled_show_exceptions
+        end
+
+        # It would be called by every request
+        # @param hash env
+        # @return array
+        #     response_code   int
+        #     response_header hash
+        #     response_body   array
+        private
+        def execute(env)
+            # check path machs the expected path
+            if matched_route_strictly? @request.path, @view.info_path
+                # check request HTTP method
+                if is_allowed_http_method @request.method
+                    # matched some route then call methods defined in concrete handlers
+                    execute_handler_methods @view.info_exec_method
+                else
+                    # request method error
+                    return Handler.call_error_handler Preference::FIELD_ROUTE_ERR_WRONG_METHOD, Env.get_all
+                end
+
+            else
+                # doesn't match any routes
+                return Handler.call_error_handler Preference::FIELD_ROUTE_ERR_MISSING_ROUTE, Env.get_all
+            end
+
+            return get_response_data
+        end
+
+        # Check does requested path correspond with the given value to #map
+        # @return bool
+        private
+        def matched_route_strictly?(requested_path, expected_path)
+            match_data = @route_regexp.match requested_path
+            if match_data.is_a? MatchData
+                # set URL path parameters to Request object
+                if @url_path_params_mapper.is_a? Hash
+                    stack = requested_path.split('/')
+                    map   = {}
+                    @url_path_params_mapper.each_pair do |name, index|
+                        map[name] = stack[index] 
+                    end
+                    @request.assign_from_url map
+                end
+
+                return true
+
+            else
+                # doesn't match, the requested path is wrong
+                return false
+            end
+        end
+
+        # Get response data and return values as rack needed
+        # @return array
+        private
+        def get_response_data
+            # return response if redirection
+            if @view.is_redirect
+                return @view.get_response_data
+            end
+
+            # set response body with template and/or layout when response body hasn't been set by __set_body
+            @view.set_body_with_tpl if !@view.is_body_set?
+
+            # make page cache file if need it
+            if @view.need_create_page_cache? @request.uri
+                @view.create_page_cache @request.uri
+            end
+
+            return @view.get_response_data
+        end
+
+        # @param string|symbol|nil task method name defined in 'klass'
+        private
+        def execute_handler_methods(task)
+            if task != nil && !task.is_a?(String) && !task.is_a?(Symbol)
+                raise HandlerError, HandlerError::MSG_WRONG_TYPE%[task.class, 'String|Symbol|nil']
+            end
+
+            # execute methods when it's defined
+            # if __pre is defined execute it first
+            return if execute_method(:__pre, self) == EXIT
+            # execute particular method specified with routes.yml when it isn't nil
+            return if execute_method(task, self) == EXIT
+            # if __post is defined execute it last
+            execute_method :__post, self
+        end
+
+        # @param method symbol|string
+        private
+        def execute_method(method, handler)
+            if !@view.is_redirect && (method != nil) && handler.respond_to?(method, true)
+                handler.method(method).call
+            end
+        end
+
+        # Is given method allowed?
+        # @pram string method
+        # @return false|nil|int
+        private
+        def is_allowed_http_method(method)
+            return false if !method.is_a? String
+            http_methods = @view.info_allow_methods
+            return true if http_methods == nil
+            http_methods = http_methods.split(',')
+            http_methods.map! do |val|
+                val.strip
+            end
+            return http_methods.index method
+        end
+    end
+end