nekonote-framework 1.0.0.pre.beta

data/lib/nekonote/puma.rb

@@ -0,0 +1,131 @@
+module Nekonote
+    class Puma
+        # @param string app_root
+        # @param string env
+        def initialize(app_root, env)
+            @app_root = app_root
+            @env      = env
+        end
+
+        # @return string
+        public
+        def get_config_path
+            return get_puma_config_file_path
+        end
+
+        # @param cmd symbol
+        public
+        def ctl_server(cmd)
+            # set pumactl command corresponded with nekonote sub command
+            case cmd
+            when :start
+                puma_cmd = 'start'
+
+            when :status
+                puma_cmd = 'status'
+
+            when :stop
+                puma_cmd = 'stop'
+
+            when :halt
+                puma_cmd = 'halt'
+
+            when :restart
+                puma_cmd = 'restart'
+
+            when :phased_restart
+                puma_cmd = 'phased-restart'
+            end
+
+            # make object
+            argv = ['-F', get_puma_config_file_path, puma_cmd] 
+            stdout_buffer = $stdout.clone
+            stderr_buffer = $stderr.clone
+
+            begin
+                if cmd == :start
+                    change_exec_file_to_puma_bin # if did't change $0 to puma/bin/puma, restart will be failed
+                end
+                cli = ::Puma::ControlCLI.new argv, STDOUT, STDERR
+
+                # get pid if it exists
+                def cli.get_pid_file_path
+                    return @pidfile
+                end
+                pid = Util::Process.get_server_pid cli.get_pid_file_path
+
+                # exit if there's no need to run Puma::ControlCLI
+                nothing_to_do = false
+                case cmd
+                when :start
+                    if pid != nil
+                        puts %(Already started with pid #{pid})
+                        nothing_to_do = true
+                    end
+
+                when :status
+                    if pid == nil
+                        puts %(Server is stopped)
+                    else
+                        puts %(Server is running with pid #{pid})
+                    end
+                    nothing_to_do = true
+
+                when :stop, :halt
+                    if pid == nil
+                        puts %(Already stopped)
+                        nothing_to_do = true
+                    end
+
+                when :restart, :phased_restart
+                    if pid == nil
+                        # it have not started!
+                        ctl_server :start
+                        nothing_to_do = true
+                    end
+                end
+
+                # exit if no need to continue task
+                if nothing_to_do
+                    $stdout = stdout_buffer
+                    $stderr = stderr_buffer
+                    exit 0
+                end
+
+                # send signal
+                # when requested 'start' it will exit here
+                cli.run
+
+            ensure
+                # it won't called if script exited
+                $stdout = stdout_buffer
+                $stderr = stderr_buffer
+            end
+        end
+
+        private
+        def change_exec_file_to_puma_bin
+            puma_bin_path = "#{::Bundler.bundle_path.to_s}/gems/puma-#{::Puma::Const::VERSION}/bin/puma"
+
+            # is it readable?
+            if !Util::Filer.available_file? puma_bin_path
+                raise PreferenceError, Error::MSG_MISSING_FILE% puma_bin_path
+            end
+
+            $0 = puma_bin_path
+        end
+
+        # @return string
+        private
+        def get_puma_config_file_path
+            file_path = "#{@app_root}/preference/#{@env}/server/puma.rb"
+
+            # is it readable?
+            if !Util::Filer.available_file? file_path
+                raise PreferenceError, Error::MSG_MISSING_FILE% file_path
+            end
+
+            return file_path
+        end
+    end
+end

data/lib/nekonote/rack/rack_static.rb

@@ -0,0 +1,17 @@
+module Nekonote
+    class RackStatic < ::Rack::Static
+        def initialize(app, options={})
+            if options[:root] == nil
+                raise Error, self.class.to_s + ' require key :root'
+            end
+
+            super
+
+            # Overwrite property for using Nekonote::RackStaticFile instead of Rack::File.
+            # This for handling the error case that file requested was not found.
+            @file_server = RackStaticFile.new options[:root]
+
+            # @file_server = Rack::File.new(root)
+        end
+    end
+end

data/lib/nekonote/rack/rack_static_file.rb

@@ -0,0 +1,19 @@
+module Nekonote
+    class RackStaticFile < ::Rack::File
+        def fail(status, body, headers = {})
+            if Preference.instance.has_error_route? Preference::FIELD_ROUTE_ERR_NOT_FOUND
+                begin
+                    # display custom error response
+                    return ::Nekonote::Handler.call_error_handler Preference::FIELD_ROUTE_ERR_NOT_FOUND, Env.get_all
+                rescue => e
+                    Error.logging_error e
+                    # error, default behavior
+                    super
+                end
+            else
+                # no error route, default behavior
+                super
+            end
+        end
+    end
+end

data/lib/nekonote/rack/url_mapper.rb

@@ -0,0 +1,193 @@
+# This class is forked from rack/urlmap.rb
+# Constant values in core source must be prefixed namespace.
+# Allows using 2-space indentation in this class because of Rack using 2-space indentation
+module Nekonote
+  class URLMapper < ::Rack::URLMap
+    # =========================================================================
+    # Start adding source code for Nekonote Framework
+    # =========================================================================
+    # @param string pattern
+    # @returns hash, string
+    def parse_url_path_params(pattern)
+      url_path_params_mapper = {}
+      # change variables in path to wild card
+      if /:.+/ =~ pattern
+        pattern.split('/').each_with_index do |inspection, index|
+          inspection.scan(/(?<=:).+/).each do |v|
+            url_path_params_mapper[v] = index
+          end
+        end
+
+        # replace variable with wildcard
+        url_path_params_mapper.each_key do |name|
+          pattern.sub! (':' + name), '.+'
+        end
+      end
+
+      return url_path_params_mapper, pattern
+    end
+
+    # @param string pattern
+    # @returns regexp, hash, string
+    def get_route_regexp(pattern)
+      # if home page
+      pattern = '/' if pattern == ''
+
+      # escape special meaning characters in regexp
+      pattern = Regexp.quote pattern
+
+      # parse path for url path parameters
+      url_path_params_mapper, pattern = parse_url_path_params pattern
+
+      pattern = %(^#{pattern}$)
+
+      # If duplocate slashes are allowed change regexp a little bit for it
+      if Preference.instance.is_allow_dup_slash?
+          pattern.gsub! '/', '/+'
+      end
+
+      match = Regexp.new pattern, nil, 'n'
+
+      return match, url_path_params_mapper, pattern
+    end
+
+    # @param string pattern
+    # @returns regexp, hash, string
+    def get_route_regexp_custom(pattern)
+      option = nil
+      code   = nil
+
+      # parse path for url path parameters
+      url_path_params_mapper, pattern = parse_url_path_params pattern
+
+      if pattern == ''
+        # home page
+        pattern = '/$'
+
+      elsif /\/[ixmn]+$/ =~ pattern
+        # there is regexp option
+        matched_str = $&.delete '/'
+        pattern     = pattern.sub /\/[ixmn]+$/, ''
+        option = 0
+        matched_str.each_char do |char|
+          case char
+          when 'i'
+            option = option | Regexp::IGNORECASE
+          when 'm'
+            option = option | Regexp::MULTILINE
+          when 'x'
+            option = option | Regexp::EXTENDED
+          when 'n'
+            code = 'n'
+          end
+        end
+      end
+
+      pattern = '^' + pattern
+
+      # If duplocate slashes are allowed change regexp a little bit for it
+      if Preference.instance.is_allow_dup_slash?
+          pattern.gsub! '/', '/+'
+      end
+
+      match = Regexp.new pattern, option, code
+
+      return match, url_path_params_mapper, pattern
+    end
+    # =========================================================================
+    # End adding source code
+    # =========================================================================
+
+    def remap(map)
+      @mapping = map.map { |location, app|
+        if location =~ %r{\Ahttps?://(.*?)(/.*)}
+          host, location = $1, $2
+        else
+          host = nil
+        end
+
+        unless location[0] == ?/
+          raise ArgumentError, "paths need to start with /"
+        end
+
+        location = location.chomp('/')
+        #match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n') # comment out of original source
+        # =========================================================================
+        # Start adding source code for Nekonote Framework
+        # =========================================================================
+        # get regexp for matching URL
+        if Preference.instance.is_path_regexp?
+          match, url_path_params_mapper, location = get_route_regexp_custom location # path will be evaluated as regexp
+        else
+          match, url_path_params_mapper, location = get_route_regexp location
+        end
+
+        # set the values to Nekonote::Handler class
+        app.route_regexp = match
+        app.url_path_params_mapper = url_path_params_mapper
+        # =========================================================================
+        # End adding source code
+        # =========================================================================
+
+        [host, location, match, app]
+      }.sort_by do |(host, location, _, _)|
+        [host ? -host.size : ::Rack::URLMap::INFINITY, -location.size]
+      end
+    end
+
+    def call(env)
+      path        = env[::Rack::PATH_INFO]
+      script_name = env[::Rack::SCRIPT_NAME]
+      http_host   = env[::Rack::HTTP_HOST]
+      server_name = env[::Rack::SERVER_NAME]
+      server_port = env[::Rack::SERVER_PORT]
+
+      is_same_server = casecmp?(http_host, server_name) ||
+                       casecmp?(http_host, "#{server_name}:#{server_port}")
+
+      @mapping.each do |host, location, match, app|
+        unless casecmp?(http_host, host) \
+            || casecmp?(server_name, host) \
+            || (!host && is_same_server)
+          next
+        end
+
+        next unless m = match.match(path.to_s)
+
+        rest = m[1]
+        next unless !rest || rest.empty? || rest[0] == ?/
+        env[::Rack::SCRIPT_NAME] = (script_name + location)
+        env[::Rack::PATH_INFO] = rest
+
+        return app.call(env)
+      end
+
+      # [404, {::Rack::CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]] comment out of original source
+      # =========================================================================
+      # Start adding source code for Nekonote Framework
+      # =========================================================================
+      if Preference.instance.has_error_route? Preference::FIELD_ROUTE_ERR_MISSING_ROUTE
+        # "missing_route" route has been defined
+        begin
+          # display custom error response
+          return ::Nekonote::Handler.call_error_handler Preference::FIELD_ROUTE_ERR_MISSING_ROUTE, env
+        rescue => e
+          Error.logging_error e
+          # error, default behavior
+          [404, {::Rack::CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+        end
+
+      else
+        # no error route, default behavior
+        [404, {::Rack::CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+      end
+      # =========================================================================
+      # End adding source code for Nekonote Framework
+      # =========================================================================
+
+    ensure
+      env[::Rack::PATH_INFO]   = path
+      env[::Rack::SCRIPT_NAME] = script_name
+    end
+  end # class URLMapper
+end # module Nekonote

data/lib/nekonote/rackup.rb

@@ -0,0 +1,319 @@
+module Nekonote
+    class Rackup
+        include Singleton
+
+        def initialize
+            begin
+                # initialize Logger
+                Nekonote.init_logger
+
+                # initialize Setting
+                Setting.init
+            rescue => e
+                Error.abort e
+            end
+        end
+
+        # @param mixed info
+        # @return hash
+        def self.get_header_rules_field(info)
+            headers = {}
+            if info.is_a? Hash
+                # just one header
+                headers = {info['name'] => info['value']}
+
+            elsif info.is_a? Array
+                # plural headers
+                headers = {}
+                info.each do |pair|
+                    headers[pair['name']] = pair['value']
+                end
+            end
+            return headers
+        end
+
+        # @param mixed info
+        # @param proc get_rule
+        # @return hash
+        def self.get_header_rules_field_having_target(info, get_rule)
+            rules = []
+            if info.is_a?(Array)
+                # multiple
+                stack = []
+                info.each do |each_ext|
+                    rule = get_rule.call each_ext
+                    stack << rule if rule != nil
+                end
+                stack.each do |rule|
+                    rules << rule
+                end
+            else
+                rule = get_rule.call info
+                rules << rule if rule != nil
+            end
+            return rules
+        end
+
+        # make data for header rules option
+        # @param hash info
+        # @return array
+        def self.get_header_rules(info)
+            rules = []
+
+            # for :all
+            headers = get_header_rules_field info['all']
+            rules << [:all, headers] if headers.size > 0
+
+            # for :directory
+            if info['directory'] != nil
+                get_rule = lambda do |data|
+                    rule = nil
+                    if data.is_a?(Hash) && data.has_key?('target')
+                        dir = data.delete 'target'
+                        dir = "/#{dir}" if !dir.start_with? '/'
+                        headers = get_header_rules_field data
+                        rule = [dir, headers] if headers.size > 0
+                    end
+                    return rule
+                end
+                rules_for_dir = get_header_rules_field_having_target info['directory'], get_rule
+                rules_for_dir.each do |rule|
+                    rules << rule
+                end
+           end
+
+            # for :extension
+            if info['extension'] != nil
+                get_rule = lambda do |data|
+                    rule = nil
+                    if data.is_a?(Hash) && data.has_key?('target')
+                        target = data.delete 'target'
+                        ext    = target.split(',')
+                        ext.map! do |v| v.strip end
+                        headers = get_header_rules_field data
+                        rule = [ext, headers] if headers.size > 0
+                    end
+                    return rule
+                end
+                rules_for_dir = get_header_rules_field_having_target info['extension'], get_rule
+                rules_for_dir.each do |rule|
+                    rules << rule
+                end
+            end
+
+            # for :regexp
+            if info['regexp'] != nil
+                get_rule = lambda do |data|
+                    rule = nil
+                    if data.is_a?(Hash) && data.has_key?('target')
+                        target = data.delete 'target'
+                        if data['ignore_case'] == true
+                            regexp = Regexp.new target, Regexp::IGNORECASE
+                        else
+                            regexp = Regexp.new target
+                        end
+                        headers = get_header_rules_field data
+                        rule = [regexp, headers] if headers.size > 0
+                    end
+                    return rule
+                end
+                rules_for_dir = get_header_rules_field_having_target info['regexp'], get_rule
+                rules_for_dir.each do |rule|
+                    rules << rule
+                end
+            end
+
+            # for :fonts
+            headers = get_header_rules_field info['fonts']
+            rules << [:fonts, headers] if headers.size > 0
+
+            return rules
+        end
+
+        # @return proc
+        public
+        def use_middlewares
+            return Proc.new do
+                # overwrite the core method of lib/rack/builder.rb
+                def self.use(middleware, *args, &block)
+                    @nekonote_middlewares = [] if !defined? @nekonote_middlewares
+                    @nekonote_middlewares << middleware.to_s
+                    super
+                end
+
+                # add the individual method
+                def self.get_nekonote_middlewares
+                    return @nekonote_middlewares
+                end
+
+                # evaluate middlewares.rb as Ruby codes
+                path = Preference.instance.path_middlewares_rb
+                begin
+                    instance_eval IO.read path
+                rescue => e
+                    warn <<EOS
+#{PreferenceError::MSG_EVAL_MIDDLEWARES% path}
+
+#{e.class}:
+    #{e.message}
+
+#{e.backtrace.join($/)}
+EOS
+                    exit 1
+                end
+
+                # display middleware list
+                is_enabled_show_exceptions = false
+                get_nekonote_middlewares.each do |middleware_name|
+                    if middleware_name == 'Rack::ShowExceptions'
+                        is_enabled_show_exceptions = true
+                    end
+                    puts " + Use -> #{middleware_name}"
+                end
+
+                Preference.instance.is_enabled_show_exceptions = is_enabled_show_exceptions
+            end
+        end
+
+        # publishing for static files
+        public
+        def define_public_dir
+            return Proc.new do |pref_public|
+                # expected Hash only
+                pref_public = {} if !pref_public.is_a? Hash
+
+                options = {
+                    :root => Nekonote.get_root_path + 'public'
+                }
+
+                # publish specific files only
+                # define published directories under 'public'
+                pub_dirs = []
+                if pref_public['published_directory'].is_a? Array
+                    pub_dirs = pref_public['published_directory']
+                    pub_dirs.map! do |val|
+                        if val.start_with? '/' 
+                            val
+                        else
+                            '/' + val
+                        end
+                    end
+                end
+                if pub_dirs.count > 0
+                    options[:urls] = pub_dirs
+                end
+
+                # define published files under 'public'
+                pub_files = []
+                if pref_public['published_file'].is_a? Array
+                    pub_files = pref_public['published_file']
+                    pub_files.map! do |val|
+                        if val.start_with? '/' 
+                            val
+                        else
+                            '/' + val
+                        end
+                    end
+                end
+                if pub_files.count > 0
+                    if options[:urls].is_a? Array
+                        options[:urls] = options[:urls] + pub_files
+                    else
+                        options[:urls] = pub_files
+                    end
+                end
+
+                # add custom headers
+                if pref_public['custom_header'].is_a? Hash
+                    rules = ::Nekonote::Rackup.get_header_rules pref_public['custom_header']
+                    if rules.size > 0
+                        options[:header_rules] = rules
+                    end
+                end
+
+                # register published static files
+                use RackStatic, options
+            end # end proc
+        end
+
+        # @return proc
+        public
+        def define_route
+            return Proc.new do |pref_route|
+                # load the common handler
+                Nekonote.load_base_handler
+
+                # load files under 'handler' direcotry
+                Dir[File.expand_path('handler', Nekonote.get_root_path) + '/**/*.rb'].each do |file|
+                    require file # TODO need auto loading
+                end
+
+                # get preferences for include
+                pref_common = Preference.instance.get_route_include
+
+                # define the routes
+                routes = {}  # instance list of app
+                paths  = []  # for duplicate check
+                pref_route.each do |info|
+                    # if include directive has been set, convert it to the directives and missing directives will be filled
+                    if info[Preference::FIELD_ROUTE_INCLUDE].is_a? String
+                        # include directive has been set in the route
+                        if pref_common[info[Preference::FIELD_ROUTE_INCLUDE]].is_a? Hash
+                            pref_common[info[Preference::FIELD_ROUTE_INCLUDE]].each_pair do |k, v|
+                                if info[k] == nil
+                                    info[k] = v
+                                else
+                                    # directive name is duplicate between route.yml and route_include.yml
+                                    # values in route.yml takes precedence over values in route_include.yml that without method or params
+                                    info[k] += ',' + v if k == Preference::FIELD_ROUTE_PARAMS || k == Preference::FIELD_ROUTE_ALLOW_METHODS
+                                end
+                            end
+                            info.delete Preference::FIELD_ROUTE_INCLUDE
+                        else
+                            # no such field in route_include.yml
+                            raise PreferenceError, PreferenceError::MSG_MISSING_INCLUDE% [info[Preference::FIELD_ROUTE_INCLUDE], Preference.instance.path_route_include_yml]
+                        end
+                    end
+
+                    # difined path field?
+                    path = info[Preference::FIELD_ROUTE_PATH]
+                    if !path.is_a? String
+                        raise PreferenceError, PreferenceError::MSG_MISSING_FIELD% [Preference::FIELD_ROUTE_PATH, Preference.instance.path_route_yml]
+                    end
+
+                    # having handler?
+                    handler = info[Preference::FIELD_ROUTE_HANDLER]
+                    if !handler.is_a? String
+                        raise PreferenceError, PreferenceError::MSG_INVALID_HANDLER_NAME% "#{handler}"
+                    end
+
+                    # validation for the field 'page_cache_time'
+                    if info[Preference::FIELD_ROUTE_PAGE_CACHE_TIME] != nil
+                        page_cache_time = info[Preference::FIELD_ROUTE_PAGE_CACHE_TIME].to_i
+                        if page_cache_time > 0
+                            info[Preference::FIELD_ROUTE_PAGE_CACHE_TIME] = page_cache_time
+                        else
+                            raise Error, Error::MSG_INVALID_FIELD% [Preference::FIELD_ROUTE_PAGE_CACHE_TIME, Preference.instance.path_route_yml]
+                        end
+                    end
+
+                    # set app
+                    begin
+                        routes[info[Preference::FIELD_ROUTE_PATH].strip] = Object.const_get(handler).new(info)
+                    rescue NameError
+                        raise PreferenceError, PreferenceError::MSG_NO_SUCH_HANDLER% info[Preference::FIELD_ROUTE_HANDLER]
+                    end
+
+                    paths << path
+                end
+
+                # is there any duplicate path?
+                if paths.size != paths.uniq.size
+                    raise PreferenceError, PreferenceError::MSG_DUPLICATE_PATH% Preference.instance.path_route_yml
+                end
+
+                run URLMapper.new routes
+            end # end proc
+        end # end #define_route
+    end
+end