nekonote-framework 1.0.0.pre.beta

data/lib/nekonote/view.rb

@@ -0,0 +1,398 @@
+module Nekonote
+    # define original liquid tag
+    ::Liquid::Template.register_tag 'env_get', TagEnvGet
+    ::Liquid::Template.register_tag 'setting_get', TagSettingGet
+
+    class View
+        NO_USING_NAME       = 'none'
+        DEFAULT_LAYOUT_NAME = 'default'
+        PATH_TO_TEMPLATE    = 'static/template'
+        PATH_TO_LAYOUT      = 'static/layout'
+
+        # accessor
+        attr_accessor :is_redirect
+        attr_reader   :is_error_route,
+                      :info_path,
+                      :info_exec_method,
+                      :info_allow_methods,
+                      :info_params,
+                      :info_content_type,
+                      :info_template,
+                      :info_layout,
+                      :info_page_cache_time
+
+        # @return array
+        def self.get_default_error_response
+            return [
+                500,
+                {
+                },
+                []
+            ]
+        end
+
+        # @param hash info
+        # @param string handler_name
+        # @param nil|string error_field_name
+        def initialize(info, handler_name, error_field_name = nil)
+            register_info_properies info
+
+            # initialize response
+            init_for_response
+
+            # check error route or not?
+            if error_field_name.is_a? String
+                @is_error_route = true
+                # set default response code for error (users can customize it on concrete handlers).
+                set_code get_error_response_code(error_field_name)
+            else
+                @is_error_route = false
+            end
+
+            # set template
+            if @info_template.is_a? String
+                # use template described in route.yml
+                @template_path = Nekonote.get_root_path + PATH_TO_TEMPLATE + '/' + @info_template + '.tpl'
+            elsif @info_template == nil
+                # set default if no template is specified
+                @template_path = get_default_template_path handler_name
+            else
+                # no template with response
+                @template_path = nil
+            end
+
+            # set layout
+            if @info_layout.is_a? String
+                # use layout described in route.yml
+                @layout_path = Nekonote.get_root_path + PATH_TO_LAYOUT + '/' + @info_layout + '.tpl'
+            elsif @info_layout == nil
+                # if no layout is specified, try to use default layout
+                @layout_path = Nekonote.get_root_path + PATH_TO_LAYOUT + '/' + DEFAULT_LAYOUT_NAME + '.tpl'
+                if !Util::Filer.available_file? @layout_path
+                    # but if it's not available, no layout with response
+                    @layout_path = nil
+                end
+            else
+                # no layout with response
+                @layout_path = nil
+            end
+
+            # assign extra fields into templates
+            assign_custom_fields info
+        end
+
+        # Initialize stored information about response
+        public
+        def init_for_response
+            @response = ::Rack::Response.new
+            set_content_type @info_content_type
+
+            # initialize the properties
+            @is_body_set = false
+            @is_redirect = false
+        end
+
+        # Is page cache enabled for this route.
+        # @return bool
+        public
+        def enable_page_cache?
+            return @info_page_cache_time.is_a? Integer
+        end
+
+        # Need to create page cache?
+        # @param string uri
+        # @return bool
+        public
+        def need_create_page_cache?(uri)
+            return enable_page_cache? && !PageCache.instance.has_available_cache?(uri, @info_page_cache_time)
+        end
+
+        # Is it Allowed to gets response data from page cache for givevn uri?
+        # @param string uri
+        # @return bool
+        public
+        def can_get_from_page_cache?(uri)
+            return enable_page_cache? && PageCache.instance.has_available_cache?(uri, @info_page_cache_time)
+        end
+
+        # Makes page cache file
+        # @param string uri
+        public
+        def create_page_cache(uri)
+            PageCache.instance.make_cache(
+                uri,
+                @response.status,
+                @response.header,
+                @response.body
+            )
+        end
+
+        # @return array
+        public
+        def get_response_data
+            return @response.finish
+        end
+
+        # Gets response data for given uri from page cache
+        # @param string uri
+        public
+        def get_response_data_from_page_cache(uri)
+            return PageCache.instance.get_page_cache uri
+        end
+
+        # @return string
+        public
+        def set_body_with_tpl
+            # 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)
+                raise ViewError, ViewError::MSG_MISSING_LAYOUT_FILE% @layout_path
+            end
+
+            @response.write get_parsed(@template_path, @layout_path)
+        end
+
+        # @param string|symbol subject
+        # @param mixed value
+        public
+        def set_header(subject, value)
+            subject = subject.to_s if subject.is_a?(Symbol)
+            raise ViewError, ViewError::MSG_WRONG_TYPE%[subject.class, 'String or Symbol'] if !subject.is_a?(String)
+            @response[subject] = value
+        end
+
+        # @param string type
+        public
+        def set_content_type(type)
+            @response['Content-Type'] = get_content_type type
+        end
+
+        # @param string|symbol subject
+        # @param mixed value
+        # @param string delimiter
+        public
+        def add_header(subject, value, delimiter)
+            subject = subject.to_s if subject.is_a?(Symbol)
+            raise ViewError, ViewError::MSG_WRONG_TYPE%[subject.class, 'String or Symbol'] if !subject.is_a?(String)
+            raise ViewError, ViewError::MSG_WRONG_TYPE%[delimiter.class, 'String'] if !delimiter.is_a?(String)
+
+            if @response.header.has_key? subject
+                @response[subject] = "#{@response[subject]}#{delimiter}#{value}"
+            else
+                set_header subject, value
+            end
+        end
+
+        # @param int code
+        public
+        def set_code(code)
+            begin
+                code = code.to_i if !code.is_a?(Fixnum)
+            rescue
+                raise ViewError, ViewError::MSG_WRONG_TYPE%[code.class, 'Fixnum or convertible types into Fixnum']
+            end
+           @response.status = code
+        end
+
+        # @param string body
+        public
+        def set_body(body)
+            if !body.is_a?(String)
+                begin
+                    body = body.to_s
+                rescue
+                    raise ViewError, ViewError::MSG_WRONG_TYPE%[body.class, 'String or convertible types into Fixnum']
+                end
+            end
+            @response.body = []
+            @response.write body
+            @is_body_set = true
+        end
+
+        # @param string body
+        public
+        def add_body(body)
+            if !body.is_a?(String)
+                begin
+                    body = body.to_s
+                rescue
+                    raise ViewError, ViewError::MSG_WRONG_TYPE%[body.class, 'String or convertible types into String']
+                end
+            end
+            @response.write body
+            @is_body_set = true
+        end
+
+        # is set something for response body?
+        public
+        def is_body_set?
+            return @is_body_set
+        end
+
+        # assign mapping into teplate and/or layout
+        # when already exst mapping it would be merged
+        # @param hash list
+        # @throw ::Nekonote::Error
+        public
+        def assign_variables(list)
+            if !list.is_a? Hash
+                raise ViewError, ViewError::MSG_FAILED_TO_ASSIGN
+            end
+
+            # convert symbol key to string key
+            list_cnv = {}
+            list.map {|pair| list_cnv[pair[0].to_s] = pair[1] }
+
+            if defined?(@mapping) && @mapping.is_a?(Hash)
+                @mapping.merge! list_cnv
+            else
+                @mapping = list_cnv
+            end
+        end
+
+        # assign custom fields into teplate and/or layout
+        # @param bool is_error_route
+        public
+        def assign_custom_fields(info)
+            fields = Preference.get_custom_fields info, @is_error_route
+            if fields.is_a?(Hash)
+                assign_variables fields
+            end
+        end
+
+        # @param hash info
+        private
+        def register_info_properies(info)
+            @info_path            = info[Preference::FIELD_ROUTE_PATH]
+            @info_exec_method     = info[Preference::FIELD_ROUTE_EXEC_METHOD]
+            @info_allow_methods   = info[Preference::FIELD_ROUTE_ALLOW_METHODS]
+            @info_params          = info[Preference::FIELD_ROUTE_PARAMS]
+            @info_content_type    = info[Preference::FIELD_ROUTE_CONTENT_TYPE]
+            @info_template        = info[Preference::FIELD_ROUTE_TEMPLATE]
+            @info_layout          = info[Preference::FIELD_ROUTE_LAYOUT]
+            @info_page_cache_time = info[Preference::FIELD_ROUTE_PAGE_CACHE_TIME]
+        end
+
+        # initialize the properties
+        private
+        def init_property
+            @is_body_set = false
+            @is_redirect = false
+        end
+
+        # Returns template path for the default when it was found and available
+        # @param string|nil
+        private
+        def get_default_template_path(handler_name)
+            return nil if !handler_name.is_a? String
+
+            # get default template path when no template specified
+            begin
+                template = handler_name.sub(/Handler$/, '').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+            rescue
+                template = nil
+            end
+
+            # invalid template
+            return nil if (template.nil? || template == '')
+
+            template_path = Nekonote.get_root_path + PATH_TO_TEMPLATE + '/' + template + '.tpl'
+            if Util::Filer.available_file? template_path
+                template_path = template_path
+            else
+                template_path = nil
+            end
+
+            return template_path
+        end
+
+        # @param string type
+        # @return string
+        private
+        def get_content_type(type)
+            type = type.intern if type.is_a?(String)
+
+            content_type = 'text/plain'
+            if type == nil
+                content_type = 'text/html'
+            elsif type == :html
+                content_type = 'text/html'
+            elsif type == :json
+                content_type = 'application/json'
+            elsif type == :xml
+                content_type = 'application/xml'
+            elsif type == :plain
+                content_type = 'text/plain'
+            end
+            return content_type
+        end
+
+        # @param string field
+        private
+        def get_error_response_code(field)
+            case field
+            when Preference::FIELD_ROUTE_ERR_MISSING_ROUTE
+                return 404
+            when Preference::FIELD_ROUTE_ERR_WRONG_METHOD
+                return 405
+            when Preference::FIELD_ROUTE_ERR_FATAL
+                return 500
+            when Preference::FIELD_ROUTE_ERR_NOT_FOUND
+                return 404
+            else
+                raise PreferenceError, PreferenceError::MSG_UNDEFINED_FIELD% field
+            end
+        end
+
+        # @param string|nil template_path
+        # @param string|nil layout_path
+        # @return string
+        private
+        def get_parsed(template_path = nil, layout_path = nil)
+            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)
+                end
+
+                if layout_path.is_a? String
+                    liq_tpl_layout = Liquid::Template.parse IO.read(layout_path)
+                end
+
+                # parse and render template
+                if liq_tpl_template.is_a? Liquid::Template
+                    content = liq_tpl_template.render @mapping
+                else
+                    content = nil
+                end
+
+                # parse and render layout
+                if liq_tpl_layout.is_a? Liquid::Template
+                    if content != nil
+                        # assgin tempalte for layout
+                        mapping = {
+                            'content' => content
+                        }
+                        # and put it to @mapping
+                        @mapping.merge! mapping
+                    end
+                    data = liq_tpl_layout.render @mapping
+
+                else
+                    # if template data is available set it to data
+                    data = content if content != nil
+                end
+
+            rescue => e
+                raise ViewError, e.message
+            end
+
+            return data
+        end
+    end
+end

data/lib/nekonote/yaml_access.rb

@@ -0,0 +1,60 @@
+module Nekonote
+    class YamlAccess
+        DIR_PREFERENCE = 'preference'
+
+        # @param string path
+        # @return hash
+        def self.get_parsed(path)
+            if !Util::Filer.available_file? path
+                return nil
+            end
+
+            begin
+                contents = YAML.load_file path
+                contents = {} if (!contents.is_a? Hash)
+                return contents
+
+            rescue Psych::SyntaxError => e
+                msg  = PreferenceError::MSG_WRONG_YAML_SYNTAX% path
+                msg += $/ + $/ + e.message
+                raise PreferenceError, msg
+            end
+        end
+
+        # Returns the parsed routing information
+        # @param string path
+        def self.get_parsed_route(path)
+            if !Util::Filer.available_file? path
+                return nil
+            end
+
+            begin
+                ast = YAML.parse_file path
+
+                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
+                        route_list[cnt] = {Preference::FIELD_ROUTE_HANDLER => node.value}
+                    elsif node.is_a? Psych::Nodes::Mapping
+                        if route_list[cnt].is_a? Hash
+                            route_list[cnt] = route_list[cnt].merge node.to_ruby
+                        end
+                    end
+                end
+
+                parsed = []
+                route_list.each do |info|
+                    parsed << info if info.is_a?(Hash)
+                end
+
+                return parsed
+
+            rescue Psych::SyntaxError => e
+                msg  = PreferenceError::MSG_WRONG_YAML_SYNTAX% path
+                msg += $/ + $/ + e.message
+                raise PreferenceError, msg
+            end
+        end
+    end
+end