nekonote-framework 1.0.0.pre.beta3 → 1.0.0.pre.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00eabea6fe9875a31c1e00c10bf8d5b69fd75df1504126ccecd9a45b0b53cc49
-  data.tar.gz: 11f1a32532b1efcaebc1fda354b594d2730a94b2910f66141e6fac1e05a1398b
+  metadata.gz: 93b75ef49754ba2acb077f4e48561f052963a1003069aacb5ea5e25c3b63ad8c
+  data.tar.gz: 991045d68698d89d11998f3799ae5ba0c9a7e8d06f79ea0a5b9b93cfe382e477
 SHA512:
-  metadata.gz: bd9e66323d6a3e68f6f36d408de30d2ce2dfc82ca1cc2e6f674821ea785551f2755c1070d0524bf6cae016f869d812c1e79ab5abf114a4f4b28551f00a7ae5d5
-  data.tar.gz: 66c85acf1a1bfc53e618f203d21405e516a8d609a377bdb0bf09d9765b16245501129b46254cd9d8846451e44d7f8dc7c7398fe115093537c11ad0f657a8c454
+  metadata.gz: c5004e020a5d4c40ccbb99a41025eda8c894a71c597f1f6486d008ecd3390f7815485761f2e25bf4a02ff4d2d1deed37b0711cc23fa84902cea84a54f96db56a
+  data.tar.gz: fbd87c7eb9ca444e8ac5761a346ea4c7df3fe8290d570fa80d5376f6dc9db3c968216e93168a50b3c705b29fce981d9581a42d930027438edb05a20f10b72a08

data/README.md

@@ -1,44 +1,43 @@
 # Nekonote Framework
-
-Nekonote Framework is a small web application framework that helps your web development.
+Simple and Lightweight Ruby Framework for Web Development
 
 ## Features
 
 ### Simple
-"Simplicity" is one of most important things. Nekonote Framework is simple and easy to learn.
+Nekonote Framework is simple and easy to learn.
 
 ### Lightweight
-Nekonote Framework is not full-stack framework. It's small and Lightweight.
+It's not a kind of full-stack framework. Small and Lightweight.
 
 ### Rack-based
-Nekonote Framework can generate Rack application easily even if you are not familiar with Rack.
+You can generate a Rack application easily.
 
 ### MVC
-Nekonote Framework is designed as Push-MVC based architecture.
+It's Push-MVC based architecture.
 
-### Application Structure
-It's possible to generate a structure of application by running nekonote command.
+### Structure
+You can get started with a application structure.
 
-### Sanitizing
-Nekonote Framework can sanitize HTTP request parameters as your expected.
+### Web Server
+"nekonote" command can controll a web server.
 
-### Strict Routes
-You can configure routes easily by the configuration files. You may set some rules to them.
+### Routing
+You can define routes for your application in the configuration files.
 
-### Error Pages
-You may configure routes for error pages by the configuration file.
+### Error Routes
+You may define the routes for when some exceptional things happend.
 
-### Separable Environments
-It's possible to separate the configuration files by environments.
+### Environments
+You can configure environments for your application.
 
 ### GUI Debuger
-The GUI-based debugger can display exception details on your browser.
+It can display exception's details on your browser.
 
-### Multiprocess-safe Logger
-Nekonote Framework provides you safety logging. It's multiprocess-safety and thread-safety.
+### Logger
+It provides you thread-safe logging.
 
-### Liquid Template Engine
-Liquid is a well-known powerful template engine. Templates are rendered by Liquid.
+Template Engine
+The templating engine on Nekonote Framework is Liquid.
 
 ## Getting Started
 

data/data/structure/preference/development/route.yml

@@ -13,11 +13,13 @@
 #    custom: some value                                            # unknown fields are not directive. It will be assigned into your templates.
 
 # ----------------------
-# Route Options
+# routing options
 # ----------------------
 preference:
     path_as_regexp: false
     allow_dup_slash: false
+    template_file_extension: tpl
+    layout_file_extension: tpl
 
 # ----------------------
 # Routes

data/lib/nekonote/core.rb

@@ -83,7 +83,7 @@ module Nekonote
 
     # 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
+        pref_logger = Preference.instance.get_logger
 
         if pref_logger['write_exception'] == true
             @@logger_write_exception = true

data/lib/nekonote/exception/error.rb

@@ -16,6 +16,7 @@ module Nekonote
         MSG_INVALID_FIELD        = %(Invalid format field '%s' in '%s'.)
         MSG_MISSING_CONST        = %(Not found such class or module or contant -> '%s'.)
         MSG_EMPTY_FILE_NOT_EMPTY = %('%s' is not empty. Failed to create an empty file.)
+        MSG_NOT_FOUND_DIRECTIVE  = %('%s' directive is required in '%s')
 
         # write message as warning to log file if logging is enabled
         # @param string msg
@@ -32,8 +33,6 @@ module Nekonote
 
         # @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-=;)" + $/
@@ -44,6 +43,9 @@ module Nekonote
                 exit 1
             end
 
+            # logging when logger is enabled
+            logging_error e
+
             raise e
         end
 

data/lib/nekonote/exception/preference_error.rb

@@ -4,8 +4,8 @@ module Nekonote
         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_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.)
+        MSG_DUPLICATE_PATH       = %(There is the duplicate path in %s. Values of 'path' directive are supposed to be unique.)
+        MSG_EVAL_MIDDLEWARES     = %(Failed to run '%s')
         MSG_FAILED_INI_HANDLER   = %(Failed to make a %s class object.)
     end
 end

data/lib/nekonote/preference.rb

@@ -8,10 +8,18 @@ module Nekonote
         # for route.yml
         FIELD_ROUTE_INCLUDE = 'include'
 
-        # for route options
-        FIELD_OPTION_ROUTE = 'preference'
+        # routing options
+        FIELD_ROUTING_OPTIONS = 'preference'
         FIELD_OPTION_ROUTE_REGEXP    = 'path_as_regexp'
         FIELD_OPTION_ALLOW_DUP_SLASH = 'allow_dup_slash'
+        FIELD_OPTION_TEMPLATE_EXT    = 'template_file_extension'
+        FIELD_OPTION_LAYOUT_EXT      = 'layout_file_extension'
+
+        # default values for routing options
+        DEFAULT_OPTION_ROUTE_REGEXP      = false
+        DEFAULT_OPTION_ALLOW_DUP_SLASH   = false
+        DEFAULT_OPTION_TEMPLATE_FILE_EXT = 'tpl'
+        DEFAULT_OPTION_LAYOUT_FILE_EXT   = 'tpl'
 
         # for route_error.yml
         FIELD_ROUTE_ERR_MISSING_ROUTE = 'missing_route'
@@ -63,8 +71,7 @@ module Nekonote
                     :path_logger_yml
 
         def initialize
-            env  = Nekonote.get_env
-            path = Nekonote.get_root_path + YamlAccess::DIR_PREFERENCE + "/#{env}/"
+            path = Nekonote.get_root_path + YamlAccess::DIR_PREFERENCE + "/#{Nekonote.get_env}/"
 
             @path_route_yml         = path + 'route.yml'
             @path_route_include_yml = path + 'route_include.yml'
@@ -73,132 +80,139 @@ module Nekonote
             @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
+            # check if GUI debugger is on? this value will be set from rackup
             @is_enabled_show_exceptions = nil
 
-            # check there are required yaml files
+            # check if config.ru and route.yml exists
             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
+            elsif !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)
+            # read preferences from configuration files
+            init_pref
         end
 
-        # @param bool fresh
-        # @return hash or exit from program
+        # @return hash
+        # @throws PreferenceError
         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
+        def get_route
             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
+        def get_route_include
             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
+        def get_route_error
             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
+        def get_public
             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
+        def get_logger
             return @parsed_logger_yml
         end
 
-        # @param bool fresh
+        # @param string field
         # @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
+        def has_error_route?(field)
+            # not found route_error.yml just return false, error pages is not required
+            if @parsed_route_error_yml == nil
+                return false
             end
 
+            return @parsed_route_error_yml.is_a?(Hash) && @parsed_route_error_yml[field][FIELD_ROUTE_HANDLER].is_a?(String)
+        end
+
+        # @return bool
+        public
+        def is_path_regexp?
             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
+        def is_allow_dup_slash?
+            return @is_allow_dup_slash
+        end
+
+        # @return string
+        public
+        def get_template_file_extension
+            return @template_file_extension
+        end
+
+        # @return string
+        public
+        def get_layout_file_extension
+            return @layout_file_extension
+        end
+
+        # initialize preferences
+        public
+        def init_pref
+            @parsed_route_yml         = YamlAccess::get_parsed_route @path_route_yml
+            @parsed_route_include_yml = YamlAccess::get_parsed @path_route_include_yml
+            @parsed_route_error_yml   = YamlAccess::get_parsed @path_route_error_yml
+            @parsed_public_yml        = YamlAccess::get_parsed @path_public_yml
+            @parsed_logger_yml        = YamlAccess::get_parsed @path_logger_yml
+
+            # check if found available route
+            if @parsed_route_yml.size == 0
+                raise PreferenceError, PreferenceError::MSG_EMPTY_YAML% @path_route_yml
             end
 
-            return @is_allow_dup_slash
+            # set route options
+            init_routing_options
+        end
+
+        # initialize routing options
+        public
+        def init_routing_options
+            @is_path_regexp          = nil
+            @is_allow_dup_slash      = nil
+            @template_file_extension = nil
+            @layout_file_extension   = nil
+
+            # read route.yml
+            pref = YamlAccess::get_parsed @path_route_yml
+
+            # not found but already it's checked though
+            return if !pref.is_a?(Hash)
+
+            routing_options = pref['preference']
+
+            # not found routing options to default
+            return if !routing_options.is_a?(Hash)
+
+            # set value to property
+            # true -> Nekonote::URLMapper, false -> :Rack::URLMap            
+            @is_path_regexp          = routing_options[FIELD_OPTION_ROUTE_REGEXP]    || DEFAULT_OPTION_ROUTE_REGEXP
+            @is_allow_dup_slash      = routing_options[FIELD_OPTION_ALLOW_DUP_SLASH] || DEFAULT_OPTION_ALLOW_DUP_SLASH
+            @template_file_extension = routing_options[FIELD_OPTION_TEMPLATE_EXT]    || DEFAULT_OPTION_TEMPLATE_FILE_EXT
+            @layout_file_extension   = routing_options[FIELD_OPTION_LAYOUT_EXT]      || DEFAULT_OPTION_LAYOUT_FILE_EXT
+
+            # validation for file extension
+            if !@template_file_extension.is_a?(String) || @template_file_extension == ''
+                raise PreferenceError, Error::MSG_WRONG_TYPE% [FIELD_OPTION_TEMPLATE_EXT, 'String']
+            elsif !@layout_file_extension.is_a?(String) || @layout_file_extension == ''
+                raise PreferenceError, Error::MSG_WRONG_TYPE% [FIELD_OPTION_LAYOUT_EXT, 'String']
+            end
         end
 
         # @param array info information about route

data/lib/nekonote/rackup.rb

@@ -149,8 +149,10 @@ module Nekonote
                 # evaluate middlewares.rb as Ruby codes
                 path = Preference.instance.path_middlewares_rb
                 begin
+                    # run middlewares.rb
                     instance_eval IO.read path
                 rescue => e
+                    # when the web server deamonized it will be output into log/puma.stderr.log
                     warn <<EOS
 #{PreferenceError::MSG_EVAL_MIDDLEWARES% path}
 
@@ -300,8 +302,8 @@ EOS
                     # set app
                     begin
                         routes[info[Preference::FIELD_ROUTE_PATH].strip] = Object.const_get(handler).new(info)
-                    rescue NameError
-                        raise PreferenceError, PreferenceError::MSG_FAILED_INI_HANDLER% info[Preference::FIELD_ROUTE_HANDLER]
+                    rescue NameError => e
+                        Error.abort e
                     end
 
                     paths << path

data/lib/nekonote/spec.rb

@@ -1,6 +1,6 @@
 module Nekonote
     LIBS_NAME   = %(nekonote-framework).freeze
-    VERSION     = %(1.0.0-beta3).freeze
+    VERSION     = %(1.0.0-beta4).freeze
     HOMEPAGE    = %(https://nekonote-framework.github.io).freeze
     SUMMARY     = %(Simple and Lightweight Ruby Framework for Web Development).freeze
     DESCRIPTION = %(Nekonote Framework is a small web application framework that helps your web development.).freeze

data/lib/nekonote/view.rb

@@ -122,13 +122,12 @@ module Nekonote
             # if nil is given for layout and/or template, No template and/or layout will be used
             if @template_path != nil && !Util::Filer.available_file?(@template_path)
                 raise ViewError, ViewError::MSG_MISSING_TEMPLATE_FILE% @template_path
-            end
 
-            if @layout_path != nil && !Util::Filer.available_file?(@layout_path)
+            elsif @layout_path != nil && !Util::Filer.available_file?(@layout_path)
                 raise ViewError, ViewError::MSG_MISSING_LAYOUT_FILE% @layout_path
             end
 
-            @response.write get_parsed(@template_path, @layout_path)
+            @response.write get_parsed
         end
 
         # @param string|symbol subject
@@ -313,14 +312,16 @@ module Nekonote
         # @return string absolute path
         private
         def get_template_path(template)
-            return Nekonote.get_root_path + PATH_TO_TEMPLATE + '/' + template + '.tpl'
+            ext = Preference.instance.get_template_file_extension
+            return "#{Nekonote.get_root_path}#{PATH_TO_TEMPLATE}/#{template}.#{ext}"
         end
 
         # @param string layout relative path to layout file
         # @return string absolute path
         private
         def get_layout_path(layout)
-            return Nekonote.get_root_path + PATH_TO_LAYOUT + '/' + layout + '.tpl'
+            ext = Preference.instance.get_layout_file_extension
+            return "#{Nekonote.get_root_path}#{PATH_TO_LAYOUT}/#{layout}.#{ext}"
         end
 
         # Returns template path for the default when it was found and available
@@ -390,21 +391,19 @@ module Nekonote
             end
         end
 
-        # @param string|nil template_path
-        # @param string|nil layout_path
         # @return string
         private
-        def get_parsed(template_path = nil, layout_path = nil)
+        def get_parsed
             data = ''
             liq_tpl_template = nil
             liq_tpl_layout   = nil
             begin
-                if template_path.is_a? String
-                    liq_tpl_template = Liquid::Template.parse IO.read(template_path)
+                if @template_path.is_a? String
+                    liq_tpl_template = Liquid::Template.parse IO.read(@template_path)
                 end
 
-                if layout_path.is_a? String
-                    liq_tpl_layout = Liquid::Template.parse IO.read(layout_path)
+                if @layout_path.is_a? String
+                    liq_tpl_layout = Liquid::Template.parse IO.read(@layout_path)
                 end
 
                 # parse and render template

data/lib/nekonote/yaml_access.rb

@@ -23,6 +23,7 @@ module Nekonote
 
         # Returns the parsed routing information
         # @param string path
+        # @return hash
         def self.get_parsed_route(path)
             if !Util::Filer.available_file? path
                 return nil
@@ -34,7 +35,7 @@ module Nekonote
                 route_list = []
                 ast.root.children.each_with_index do |node, index|
                     cnt = index / 2
-                    if node.is_a?(Psych::Nodes::Scalar) && node.value != Preference::FIELD_OPTION_ROUTE
+                    if node.is_a?(Psych::Nodes::Scalar) && node.value != Preference::FIELD_ROUTING_OPTIONS
                         route_list[cnt] = {Preference::FIELD_ROUTE_HANDLER => node.value}
                     elsif node.is_a? Psych::Nodes::Mapping
                         if route_list[cnt].is_a? Hash

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nekonote-framework
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta3
+  version: 1.0.0.pre.beta4
 platform: ruby
 authors:
 - khotta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-05 00:00:00.000000000 Z
+date: 2018-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: color_echo