nekonote-framework 1.0.0.pre.beta

data/lib/nekonote/handler/protected_methods.rb

@@ -0,0 +1,119 @@
+# protected methods for conclete handlers
+module Nekonote
+    class Handler
+        module ProtectedMethods
+            # assign variables into tempate and layout
+            # @param hash list
+            # @throw ::Nekonote::Error
+            protected
+            def __assign(list)
+                @view.assign_variables list
+            end
+
+            # @param type string|symbol
+            protected
+            def __set_content_type(type)
+                @view.set_content_type type
+            end
+
+            # @param string|symbol subject
+            # @param mixed value
+            protected
+            def __set_header(subject, value)
+                @view.set_header(subject, value)
+            end
+
+            # @param hash headers
+            protected
+            def __set_headers(headers)
+                raise HandlerError, HandlerError::MSG_WRONG_TYPE%[headers.class, 'Hash'] if !headers.is_a?(Hash)
+                headers.each_pair do |key, val|
+                    @view.set_header(key, val)
+                end
+            end
+
+            # @param string|symbol subject
+            # @param mixed value
+            # @param string delimiter
+            protected
+            def __add_header(subject, value, delimiter = '; ')
+                @view.add_header subject, value, delimiter
+            end
+
+            # @param int code
+            protected
+            def __set_code(code)
+                @view.set_code code
+            end
+
+            # @param string body
+            protected
+            def __set_body(body)
+                @view.set_body body
+            end
+
+            # @param string body
+            protected
+            def __add_body(body)
+                @view.add_body body
+            end
+
+            # @param hash body
+            protected
+            def __set_json_body(body)
+                raise HandlerError, HandlerError::MSG_WRONG_TYPE%[body.class, 'Hash'] if !body.is_a?(Hash)
+                require 'json' if !defined? JSON
+                __set_body JSON.pretty_generate(body)
+            end
+
+            # Get values in a specified field(s).
+            # @param string|synbol fields you can set plual arguments like field1, field2, field3, ...
+            # @return mixed|nil in the case of that missing specified key or missing fields will return nil
+            protected
+            def __setting_get(*fields)
+                return Nekonote::Setting.get fields
+            end
+
+            # @return array
+            protected
+            def __setting_keys
+                return Nekonote::Setting.keys
+            end
+
+            # 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
+            protected
+            def __env_get(field = nil)
+                return Nekonote::Env.get field
+            end
+
+            # @return array
+            protected
+            def __env_keys
+                return Nekonote::Env.keys
+            end
+
+
+            # @param string dest
+            # @param int code
+            protected
+            def __redirect(dest, code=302)
+                # validation for types
+                raise HandlerError, HandlerError::MSG_WRONG_TYPE%[dest.class, 'String'] if !dest.is_a?(String)
+                if !code.is_a?(Fixnum)
+                    begin
+                    code = code.to_i
+                    rescue
+                        raise HandlerError, HandlerError::MSG_WRONG_TYPE%[code.class, 'Fixnum or convertible types into Fixnum']
+                    end
+                end
+
+                # set redirect information
+                __set_code code
+                __set_header 'Location', dest
+                @view.is_redirect = true
+            end
+        end
+    end
+end

data/lib/nekonote/liquid/tag_env_get.rb

@@ -0,0 +1,12 @@
+module Nekonote
+    class TagEnvGet < Liquid::Tag
+        def initialize(tag_name, val, parse_context)
+            super
+            @val = val.strip
+        end
+
+        def render(context)
+            return Env.get @val
+        end
+    end
+end

data/lib/nekonote/liquid/tag_setting_get.rb

@@ -0,0 +1,12 @@
+module Nekonote
+    class TagSettingGet < Liquid::Tag
+        def initialize(tag_name, val, parse_context)
+            super
+            @val = val.strip.split ','
+        end
+
+        def render(context)
+            return Nekonote::Setting.get @val
+        end
+    end
+end

data/lib/nekonote/logger.rb

@@ -0,0 +1,135 @@
+module Nekonote
+    class Logger
+        include Singleton
+        DEBUG = 0
+        INFO  = 1
+        WARN  = 2
+        ERROR = 3
+        FATAL = 4
+
+        public
+        def init(pref)
+            logf  = pref['logfile']%Nekonote.get_env
+            limit = pref['limit']
+            keep  = pref['keep'].to_i
+
+            if logf == nil || limit == nil || keep == nil
+                raise LoggerError, LoggerError::MSG_MISSING_LOGFILE
+            end
+
+            if !logf.start_with? '/'
+                # when log file path is relative
+                logf = Nekonote.get_root_path + logf
+            end
+
+            # initialize logger
+            @logger = SimpleRotate.instance
+            set_optional pref
+            begin
+                @logger.init logf, limit, keep
+            rescue
+                msg = $/ + Error::SPACE + "Logger definitions are: logfile = #{logf}, limit = #{limit}, keep = #{keep}"
+                raise LoggerError, LoggerError::MSG_FAILED_INITIALIZE%[ENV['USER'], logf] + msg
+            end
+
+            # set default log level
+            @default_log_level = get_log_level_by_name pref['default_log_level']
+            switch_level @default_log_level
+        end
+
+        # @param mixed msg
+        public
+        def write(msg, level = nil)
+            if level != nil
+                switch_level level
+            end
+            @logger << msg
+        end
+
+        public
+        def set_level_default
+            switch_level @default_log_level
+        end
+
+        # @param string log_level_name
+        private
+        def get_log_level_by_name(log_level_name)
+            case log_level_name
+            when 'debug'
+                level = DEBUG
+            when 'info'
+                level = INFO
+            when 'warn'
+                level = WARN
+            when 'error'
+                level = ERROR
+            when 'fatal'
+                level = FATAL
+            else
+                # set default level for missing or unknown value is given
+                level = INFO
+            end
+            return level
+        end
+
+        # @param int level
+        private
+        def switch_level(level)
+            case level
+            when DEBUG
+                @logger.debug
+            when INFO
+                @logger.info
+            when WARN
+                @logger.warn
+            when ERROR
+                @logger.error
+            when FATAL
+                @logger.fatal
+            else
+                raise LoggerError. LoggerError::MSG_UNDIFINED_LOG_LEVEL
+            end
+        end
+
+        # set optional preferences to @logger
+        # @param array pref
+        private
+        def set_optional(pref)
+            begin
+                @logger.logging_format = pref['format']['log']
+                @logger.date_format    = pref['format']['datetime']
+                @logger.threshold      = pref['threshold'].upcase
+                @logger.sleep_time     = pref['sleeptime']
+
+                if pref['compress']['enabled'] == true
+                    @logger.compress_level pref['compress']['level']
+                end
+
+                if pref['with_stdout'] == true
+                    @logger.with_stdout
+                end
+
+                if pref['verbose'] == false
+                    @logger.silence
+                end
+
+                if pref['psync'] == true
+                    @logger.psync
+                end
+
+                if pref['flush'] == true
+                    @logger.enable_wflush
+                end
+
+            rescue
+                raise LoggerError, LoggerError::MSG_FAILED_DEF_OPT
+            end
+        end
+    end
+end
+
+# @param mixed msg
+# @param int level
+def logwrite(msg, level = nil)
+    Nekonote::Logger.instance.write msg, level
+end

data/lib/nekonote/page_cache.rb

@@ -0,0 +1,111 @@
+module Nekonote
+    class PageCache
+        include Singleton
+        CACHE_DIR = 'cache'
+
+        def initialize
+            @cache_path = Nekonote.get_root_path + CACHE_DIR
+
+            # check the accessibility
+            if !Util::Filer.available_dir? @cache_path
+                raise PageCacheError, PageCacheError::MSG_CHACHE_DIR_WRONG_PERMIT% @cache_path
+            end
+        end
+
+        # @return bool
+        public
+        def cache_clear
+            files = Dir.glob("#{@cache_path}/*")
+            if files.size > 0
+                deleted = true
+            else
+                deleted = false
+            end
+
+            begin
+                files.each do |full_path|
+                    File.delete full_path
+                end
+            rescue Errno::EISDIR
+                raise PageCacheError, PageCacheError::MSG_THERE_IS_DIRECTORY
+            end
+
+            return deleted
+        end
+
+        # Makes a cache file newly.
+        # The cache files will be created under 'cache' directory and its filename is SHA-256 hash value.
+        # @param string uri
+        # @param int code
+        # @param hash header
+        # @param array body
+        public
+        def make_cache(uri, code, header, body)
+            created_at = Time.now.to_i
+            data = {
+                :code   => code,
+                :header => header,
+                :body   => body
+            }
+            data = [code, header, body]
+            serialized_data = Marshal.dump data
+
+            # create new page cache file, delete it if it already exists
+            File.open(get_cache_file_path(uri), File::RDWR|File::CREAT|File::TRUNC) do |f|
+                f.flock File::LOCK_EX
+                f.puts created_at
+                f.print serialized_data
+                f.flock File::LOCK_UN
+            end
+        end
+
+        # @param string uri
+        # array
+        public
+        def get_page_cache(uri)
+            response_data = []
+            File.open(get_cache_file_path(uri), 'r') do |f|
+                f.flock File::LOCK_SH
+                f.readline
+                response_data = Marshal.load(f.read)
+                f.flock File::LOCK_UN
+            end
+            return response_data
+        end
+
+        # Returns true if cache file exists and its valid time hasn't passed.
+        # @param string uri
+        # @param int page_cache_time
+        # @return bool
+        public
+        def has_available_cache?(uri, page_cache_time)
+            path = get_cache_file_path uri
+            # check cache file exists?
+            return false if !Util::Filer.available_file? path
+
+            # check expiration
+            latest_access = 0
+            File.open(get_cache_file_path(uri), 'r') do |f|
+                f.flock File::LOCK_SH
+                latest_access = f.readline.strip.to_i
+                f.flock File::LOCK_UN
+            end
+            sec_passed = Time.now.to_i - latest_access # passed sec
+
+            # return false if page_cache_time has passed
+            if page_cache_time < sec_passed
+                return false
+            end
+
+            # availale
+            return true
+        end
+
+        # @param string uri
+        # @return string SHA-256 hash value
+        public
+        def get_cache_file_path(uri)
+            return "#{@cache_path}/#{Digest::SHA256.hexdigest(uri)}"
+        end
+    end
+end

data/lib/nekonote/preference.rb

@@ -0,0 +1,215 @@
+module Nekonote
+    class Preference
+        include Singleton
+
+        # hidden file name for reloading preferences
+        FILE_NAME_FOR_RELOAD = '.reload_preference'
+
+        # for route.yml
+        FIELD_ROUTE_INCLUDE = 'include'
+
+        # for route options
+        FIELD_OPTION_ROUTE = 'preference'
+        FIELD_OPTION_ROUTE_REGEXP    = 'path_as_regexp'
+        FIELD_OPTION_ALLOW_DUP_SLASH = 'allow_dup_slash'
+
+        # for route_error.yml
+        FIELD_ROUTE_ERR_MISSING_ROUTE = 'missing_route'
+        FIELD_ROUTE_ERR_WRONG_METHOD  = 'wrong_http_method'
+        FIELD_ROUTE_ERR_FATAL         = 'fatal'
+        FIELD_ROUTE_ERR_NOT_FOUND     = 'not_found'
+
+        # for route.yml and route_error.yml
+        FIELD_ROUTE_PATH            = 'path'
+        FIELD_ROUTE_EXEC_METHOD     = 'execute'
+        FIELD_ROUTE_ALLOW_METHODS   = 'method'
+        FIELD_ROUTE_PARAMS          = 'params'
+        FIELD_ROUTE_CONTENT_TYPE    = 'content'
+        FIELD_ROUTE_TEMPLATE        = 'template'
+        FIELD_ROUTE_LAYOUT          = 'layout'
+        FIELD_ROUTE_PAGE_CACHE_TIME = 'page_cache_time'
+        FIELD_ROUTE_HANDLER         = 'handler'
+
+        # Except these fields are custom fields
+        FIELDS_IN_ROUTE = [
+            FIELD_ROUTE_PATH,
+            FIELD_ROUTE_EXEC_METHOD,
+            FIELD_ROUTE_ALLOW_METHODS,
+            FIELD_ROUTE_PARAMS,
+            FIELD_ROUTE_CONTENT_TYPE,
+            FIELD_ROUTE_TEMPLATE,
+            FIELD_ROUTE_LAYOUT,
+            FIELD_ROUTE_PAGE_CACHE_TIME,
+            FIELD_ROUTE_HANDLER
+        ]
+        FIELDS_IN_ROUTE_ERROR = [
+            FIELD_ROUTE_HANDLER,
+            FIELD_ROUTE_EXEC_METHOD,
+            FIELD_ROUTE_CONTENT_TYPE,
+            FIELD_ROUTE_TEMPLATE,
+            FIELD_ROUTE_LAYOUT,
+            FIELD_ROUTE_PAGE_CACHE_TIME
+        ]
+
+        # allowed to read or write from context of outside
+        attr_accessor :is_enabled_show_exceptions
+
+        # only reading is allowed
+        attr_reader :path_route_yml,
+                    :path_route_include_yml,
+                    :path_route_error_yml,
+                    :path_public_yml,
+                    :path_middlewares_rb,
+                    :path_logger_yml
+
+        def initialize
+            env  = Nekonote.get_env
+            path = Nekonote.get_root_path + YamlAccess::DIR_PREFERENCE + "/#{env}/"
+
+            @path_route_yml         = path + 'route.yml'
+            @path_route_include_yml = path + 'route_include.yml'
+            @path_route_error_yml   = path + 'route_error.yml'
+            @path_public_yml        = path + 'public.yml'
+            @path_middlewares_rb    = path + 'middlewares.rb'
+            @path_logger_yml        = path + 'logger.yml'
+
+            @parsed_route_yml         = nil
+            @parsed_route_include_yml = nil
+            @parsed_route_error_yml   = nil
+            @parsed_public_yml        = nil
+            @parsed_mw_yml            = nil
+            @parsed_logger_yml        = nil
+
+            # in route.yml
+            @is_path_regexp     = nil
+            @is_allow_dup_slash = nil
+
+            # in middleware.yml
+            @is_enabled_show_exceptions = nil
+
+            # check there are required yaml files
+            if !Util::Filer.available_file? 'config.ru'
+                msg  = Error::MSG_MISSING_RACKUP% @@root_path + $/
+                msg += Error::SPACE + Error::MSG_WRONG_ROOT
+                raise Error, msg
+            end
+
+            if !Util::Filer.available_file? @path_route_yml
+                raise PreferenceError, Error::MSG_MISSING_FILE% @path_route_yml
+            end
+        end
+
+        # @param string field
+        # @return bool
+        public
+        def has_error_route?(field)
+            pref = get_route_error
+
+            # missing route_error.yml
+            if pref == nil
+                Error.warning "Missing a file which for error routes #{@path_route_error_yml}."
+                return false
+            end
+
+            return pref[field].is_a?(Hash) && pref[field][FIELD_ROUTE_HANDLER].is_a?(String)
+        end
+
+        # @param bool fresh
+        # @return hash or exit from program
+        public
+        def get_route(fresh = false)
+            if !@parsed_route_yml.is_a?(Hash) || fresh
+                @parsed_route_yml = YamlAccess::get_parsed_route @path_route_yml
+                if @parsed_route_yml.size == 0
+                    raise PreferenceError, PreferenceError::MSG_EMPTY_YAML% @path_route_yml
+                end
+            end
+            return @parsed_route_yml
+        end
+
+        # @param bool fresh
+        # @return hash
+        public
+        def get_route_include(fresh = false)
+            if !@parsed_route_include_yml.is_a?(Hash) || fresh
+                @parsed_route_include_yml = YamlAccess::get_parsed @path_route_include_yml
+            end
+            return @parsed_route_include_yml
+        end
+
+        # @param bool fresh
+        # @return hash
+        public
+        def get_route_error(fresh = false)
+            if !@parsed_route_error_yml.is_a?(Hash) || fresh
+                @parsed_route_error_yml = YamlAccess::get_parsed @path_route_error_yml
+            end
+            return @parsed_route_error_yml
+        end
+
+        # @param bool fresh
+        # @return hash
+        public
+        def get_public(fresh = false)
+            if !@parsed_public_yml.is_a?(Hash) || fresh
+                @parsed_public_yml = YamlAccess::get_parsed @path_public_yml
+            end
+            return @parsed_public_yml
+        end
+
+        # @param bool fresh
+        # @return hash
+        public
+        def get_logger(fresh = false)
+            if !@parsed_logger_yml.is_a?(Hash) || fresh
+                @parsed_logger_yml = YamlAccess::get_parsed @path_logger_yml
+            end
+            return @parsed_logger_yml
+        end
+
+        # @param bool fresh
+        # @return bool
+        public
+        def is_path_regexp?(fresh = false)
+            if @is_path_regexp == nil || fresh
+                pref = YamlAccess::get_parsed @path_route_yml
+
+                if pref[FIELD_OPTION_ROUTE].is_a?(Hash) \
+                    && (pref[FIELD_OPTION_ROUTE][FIELD_OPTION_ROUTE_REGEXP] == true || pref[FIELD_OPTION_ROUTE][FIELD_OPTION_ROUTE_REGEXP] == 1)
+                    @is_path_regexp = true # using Nekonote::URLMapper
+                else
+                    @is_path_regexp = false # using ::Rack::URLMap
+                end
+            end
+
+            return @is_path_regexp
+        end
+
+        # @param bool fresh
+        # @return bool
+        public
+        def is_allow_dup_slash?(fresh = false)
+            if @is_allow_dup_slash == nil || fresh
+                pref = YamlAccess::get_parsed @path_route_yml
+                if pref[FIELD_OPTION_ROUTE].is_a?(Hash) && pref[FIELD_OPTION_ROUTE][FIELD_OPTION_ALLOW_DUP_SLASH] != nil
+                    @is_allow_dup_slash = pref[FIELD_OPTION_ROUTE][FIELD_OPTION_ALLOW_DUP_SLASH]
+                else
+                    @is_allow_dup_slash = false
+                end
+            end
+
+            return @is_allow_dup_slash
+        end
+
+        # @param array info information about route
+        # @param bool is_error_route
+        def self.get_custom_fields(info, is_error_route = false)
+            except_fields = is_error_route ? FIELDS_IN_ROUTE_ERROR : FIELDS_IN_ROUTE
+            except_fields.each do |field_name|
+                info.delete field_name
+            end
+
+            return info
+        end
+    end
+end