nekonote-framework 1.0.0.pre.beta

data/lib/nekonote/request.rb

@@ -0,0 +1,295 @@
+module Nekonote
+    class Request
+        STRING  = 'string'
+        INTEGER = 'int'
+        ARRAY   = 'array'
+        FLOAT   = 'float'
+        BOOL    = 'bool'
+
+        # accessor
+        attr_reader :path,
+                    :uri,
+                    :method,
+                    :payload
+
+        # @param hash env
+        # @param string|nil restricted
+        def initialize(env, restricted = nil)
+            # set properties
+            @path   = env['REQUEST_PATH']
+            @uri    = env['REQUEST_URI']
+            @method = env['REQUEST_METHOD']
+            @accepted_list = get_accepted_list restricted
+
+            # query string
+            @query_string     = {}
+            @query_string_raw = {}
+
+            # POST data
+            @post_data     = {}
+            @post_data_raw = {}
+
+            # URL path parameters
+            @path_params     = {}
+            @path_params_raw = {}
+
+            # request body
+            @payload = nil
+
+            # set query string
+            if env['QUERY_STRING'].is_a? String
+                @query_string_raw = get_param_maps env['QUERY_STRING']
+                @query_string     = get_sanitized @query_string_raw
+            end
+
+            # set POST data
+            if env['rack.input'].is_a? StringIO
+                @post_data_raw = get_param_maps env['rack.input'].gets
+                @post_data     = get_sanitized @post_data_raw
+            end
+        end
+
+        # Returns sanitized query string
+        # @params string|symbol name
+        # @return mixed
+        public
+        def query_string(name = nil)
+            return get_value name, @query_string
+        end
+
+        # Returns raw query string
+        # @params string|symbol name
+        # @return mixed
+        public
+        def query_string_raw(name = nil)
+            return get_value name, @query_string_raw
+        end
+
+        # Returns sanitized POST data
+        # @params string|symbol name
+        # @return mixed
+        public
+        def post_data(name = nil)
+            return get_value name, @post_data
+        end
+
+        # Returns raw POST data
+        # @params string|symbol name
+        # @return mixed
+        public
+        def post_data_raw(name = nil)
+            return get_value name, @post_data_raw
+        end
+
+        # Returns sanitized URL parameters
+        # @params string|symbol name
+        # @return mixed
+        public
+        def path_params(name = nil)
+            return get_value name, @path_params
+        end
+
+        # Returns raw URL parameters
+        # @params string|symbol name
+        # @return mixed
+        public
+        def path_params_raw(name = nil)
+            return get_value name, @path_params_raw
+        end
+
+        # Returns sanitized parameters
+        # @params string|symbol name
+        # @return mixed
+        public
+        def params(name = nil)
+            case @method
+            when 'GET'
+                maps = @query_string
+            when 'POST'
+                maps = @post_data
+            else
+                maps = {}
+            end
+            return get_value name, maps
+        end
+
+        # Returns raw parameters
+        # @params string|symbol name
+        # @return mixed
+        public
+        def params_raw(name = nil)
+            case @method
+            when 'GET'
+                maps = @query_string_raw
+            when 'POST'
+                maps = @post_data_raw
+            else
+                maps = {}
+            end
+            return get_value name, maps
+        end
+
+        # Returns parsed payload as json format
+        # @return hash|nil|false
+        public
+        def json_payload
+            if @payload != nil
+                begin
+                    parsed = JSON.parse @payload
+                rescue
+                    # unable to parse
+                    parsed = false
+                end
+            else
+                # no payload given
+                parsed = nil
+            end
+
+            return parsed
+        end
+
+        # @param hash map
+        public
+        def assign_from_url(map)
+            return nil if !map.is_a? Hash
+
+            # set url params
+            @path_params_raw = map
+            @path_params     = get_sanitized @path_params_raw
+        end
+
+        # @param mixed payload
+        public
+        def set_payload(payload)
+            @payload = payload
+        end
+
+        # @param string|symbol name
+        # @return bool
+        public
+        def valid_str?(name)
+            params(name) != nil && params(name) != ''
+        end
+
+        # @param string|symbol name
+        public
+        def having?(name)
+            params(name) != nil
+        end
+
+        # @param string|symbol name
+        # @param hash maps
+        # @return mixed
+        private
+        def get_value(name, maps)
+            if name.is_a? String
+                return maps[name]
+
+            elsif name.is_a? Symbol
+                return maps[name.to_s]
+
+            else
+                return maps
+            end
+        end
+
+        # Returns the accepable name list
+        # @param string|nil restricted
+        # @return array
+        private
+        def get_accepted_list(restricted)
+            accepted_list = []
+            if restricted.is_a? String
+                restricted.split(',').each do |data|
+                    data.strip!
+                    pair = data.split('=')
+                    if pair.size != 2
+                        raise Error, Error::MSG_INVALID_FIELD%['params', Preference.instance.path_route_yml]
+                    end
+                    # add field name and hash as Hash into array
+                    accepted_list << {pair[0] => pair[1]}
+                end
+            end
+
+            return accepted_list
+        end
+
+        # @param string str query string
+        # @return hash
+        private
+        def get_param_maps(str)
+            maps = {}
+            return maps if !str.is_a? String
+
+            str.split('&').each do |field|
+                pair = field.split('=')
+                if pair.size == 2
+                    v = pair[1]
+                else
+                    v = nil
+                end
+                maps[pair[0]] = v
+            end
+
+            return maps
+        end
+
+        # Removing waste parameter and converting to the exected type
+        # @param hash maps
+        # @param bool decode
+        # @return hash
+        private
+        def get_sanitized(maps, decode = false)
+            return maps if @accepted_list.size == 0
+
+            sanitized_maps = {}
+            @accepted_list.each do |field|
+                field.each_pair do |name, type|
+                    converted = get_expected type, maps[name]
+
+                    # URL decode if necessary
+                    if decode || converted.is_a?(String)
+                        converted = URI.decode_www_form_component converted
+                    end
+
+                    sanitized_maps[name] = converted
+                end
+            end
+
+            return sanitized_maps
+        end
+
+        # @param string type type expected
+        # @param mixed value real value
+        # @param string converted value by the expected type
+        private
+        def get_expected(type, value)
+            return nil if value == nil
+
+            v = nil
+            begin
+                case type
+                when INTEGER
+                    v = value.to_i
+                when STRING
+                    v = value.to_s
+                when ARRAY
+                    v = value.to_s.split(',')
+                    v.map! { |val| val.strip }
+                when FLOAT
+                    v = value.to_f
+                when BOOL
+                    if value == nil || value == false || value == 'false' || value == 0 || value == '0' || value == 'no' || value == ''
+                        v = false
+                    else
+                        v = true
+                    end
+                end
+            rescue
+                # value is nil if failed to convert value to expected type
+            end
+
+            return v
+        end
+    end
+end

data/lib/nekonote/setting.rb

@@ -0,0 +1,59 @@
+module Nekonote
+    class Setting
+        include Singleton
+        DIR_SETTING = 'setting'
+
+        # read yaml data from files under setting directory
+        def self.init
+            path = Nekonote.get_root_path + YamlAccess::DIR_PREFERENCE + '/' + Nekonote.get_env + '/' + DIR_SETTING
+            Dir.chdir path
+
+            @setting = {}
+            Dir["#{Dir.pwd}/**/*.yml"].each do |file|
+                next if File.directory? file
+                parsed = YamlAccess::get_parsed file
+                if parsed.is_a? Hash
+                    @setting.merge! parsed
+                end
+            end
+        end
+
+        # Get all root filed names
+        # @return array
+        def self.keys
+            return @setting.keys
+        end
+
+        # Get the whole environments
+        # @return hash
+        def self.get_all
+            return @setting
+        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
+        def self.get(*fields)
+            if !defined?(@setting) || !@setting.is_a?(Hash)
+                return nil
+            end
+
+            if fields.count == 1 && fields[0].is_a?(Array)
+                fields = fields[0]
+            end
+
+            stack = nil
+            fields.each do |field|
+                field = field.to_s.strip
+                if stack.is_a? Hash
+                    # get next field
+                    stack = stack[field]
+                else
+                    stack = @setting[field]
+                end
+            end
+
+            return stack
+        end
+    end
+end

data/lib/nekonote/spec.rb

@@ -0,0 +1,22 @@
+module Nekonote
+    LIBS_NAME   = %(nekonote-framework).freeze
+    VERSION     = %(1.0.0-beta).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
+    INSTALL_MESSAGE = <<EOS
+
+.*･゜ﾟ･*:.｡..｡.:･Thanks installing Nekonote Framework .*･゜ﾟ･*:.｡..｡.:*･
+
+       ^___^
+      (=^x^=) < meow meow
+      /    )                   !
+ . ~~(  h h  . .   .     .  . . =(**=)~~
+
+Note:
+  Installing dependent libraries is not completed yet.
+  After generating an application structure by 'nekonote new app some_app_name', you are supposed to get a Gemfile to install the dependencies.
+  Please install the dependent libraries from the Gemfile by Bundler.
+
+EOS
+end

data/lib/nekonote/util/filer.rb

@@ -0,0 +1,69 @@
+module Nekonote
+    module Util
+        module Filer
+            # is path file? and is it readable?
+            # @param string|io path
+            # @return bool
+            def available_file?(path)
+                return File.file?(path) && File.readable?(path)
+            end
+
+            # is path directory? and is it friendly permission?
+            # @param string|io path
+            # @return bool
+            def available_dir?(path)
+                evaluation = false
+                if File.directory? path
+                    stat = File::Stat.new path
+                    evaluation = stat.readable? && stat.writable? && stat.executable?
+                end
+                return evaluation
+            end
+
+            # Makes an empty file named the given name if it doesn't exist
+            # @param string path
+            def safe_make_empty_file(path)
+                if File.exist? path
+                    File.open(path, 'r') do |f|
+                        if !f.read.empty?
+                            raise Error, Error::MSG_EMPTY_FILE_NOT_EMPTY% path
+                        end
+                    end
+                end
+
+                # make an empty file
+                File.open(path, 'a') do |f|
+                end
+            end
+
+            # @param string path
+            def safe_delete_empty_file(path)
+                if File.exist? path
+                    File.open(path, 'r') do |f|
+                        if !f.read.empty?
+                            raise Error, Error::MSG_EMPTY_FILE_NOT_EMPTY% path
+                        end
+                    end
+                end
+
+                # delete an empty file
+                File.delete path
+            end
+
+            # delete end of slash if it exists
+            # @param string path
+            # @return string
+            def unslashed(path)
+                path.sub! /\/$/, '' if path.end_with? '/'
+                return path
+            end
+
+            # define them as module function
+            module_function :available_file?,
+                            :available_dir?,
+                            :safe_make_empty_file,
+                            :safe_delete_empty_file,
+                            :unslashed
+        end
+    end
+end

data/lib/nekonote/util/process.rb

@@ -0,0 +1,43 @@
+module Nekonote
+    module Util
+        module Process
+            # @param string path
+            # @return int|nil
+            def get_server_pid(path)
+                return nil if !Filer.available_file? path
+
+                pid = nil
+                File.open(path, 'r') do |f|
+                    pid = f.read
+                    pid.rstrip! && pid = pid.to_i if pid.is_a? String
+                end
+
+                # There's pid file but actually the process is dead
+                if pid != nil && !alive_process?(pid)
+                    pid = nil
+                end
+
+                return pid
+            end
+
+            # Is process of given pid running?
+            # @param int pid
+            # @return bool
+            def alive_process?(pid)
+                return false if !pid.is_a? Integer
+
+                begin
+                    ::Process.getpgid pid
+                    alive = true
+                rescue Errno::ESRCH
+                    alive = false
+                end
+
+                return alive
+            end
+
+            module_function :get_server_pid,
+                            :alive_process?
+        end
+    end
+end