SisMaker
/
yzyCli


								-- -----------------------------------------------------------------------------

								-- -- URI parsing, composition and relative URL resolution

								-- -- LuaSocket toolkit.

								-- -- Author: Diego Nehab

								-- -----------------------------------------------------------------------------


								-- -----------------------------------------------------------------------------

								-- -- Declare module

								-- -----------------------------------------------------------------------------

								-- local string = require("string")

								-- local base = _G

								-- local table = require("table")

								-- local socket = require("socket")


								-- socket.url = {}

								-- local _M = socket.url


								-- -----------------------------------------------------------------------------

								-- -- Module version

								-- -----------------------------------------------------------------------------

								-- _M._VERSION = "URL 1.0.3"


								-- -----------------------------------------------------------------------------

								-- -- Encodes a string into its escaped hexadecimal representation

								-- -- Input

								-- --   s: binary string to be encoded

								-- -- Returns

								-- --   escaped representation of string binary

								-- -----------------------------------------------------------------------------

								-- function _M.escape(s)

								--     return (string.gsub(s, "([^A-Za-z0-9_])", function(c)

								--         return string.format("%%%02x", string.byte(c))

								--     end))

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Protects a path segment, to prevent it from interfering with the

								-- -- url parsing.

								-- -- Input

								-- --   s: binary string to be encoded

								-- -- Returns

								-- --   escaped representation of string binary

								-- -----------------------------------------------------------------------------

								-- local function make_set(t)

								--     local s = {}

								--     for i,v in base.ipairs(t) do

								--         s[t[i]] = 1

								--     end

								--     return s

								-- end


								-- -- these are allowed withing a path segment, along with alphanum

								-- -- other characters must be escaped

								-- local segment_set = make_set {

								--     "-", "_", ".", "!", "~", "*", "'", "(",

								--     ")", ":", "@", "&", "=", "+", "$", ",",

								-- }


								-- local function protect_segment(s)

								--     return string.gsub(s, "([^A-Za-z0-9_])", function (c)

								--         if segment_set[c] then return c

								--         else return string.format("%%%02x", string.byte(c)) end

								--     end)

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Encodes a string into its escaped hexadecimal representation

								-- -- Input

								-- --   s: binary string to be encoded

								-- -- Returns

								-- --   escaped representation of string binary

								-- -----------------------------------------------------------------------------

								-- function _M.unescape(s)

								--     return (string.gsub(s, "%%(%x%x)", function(hex)

								--         return string.char(base.tonumber(hex, 16))

								--     end))

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Builds a path from a base path and a relative path

								-- -- Input

								-- --   base_path

								-- --   relative_path

								-- -- Returns

								-- --   corresponding absolute path

								-- -----------------------------------------------------------------------------

								-- local function absolute_path(base_path, relative_path)

								--     if string.sub(relative_path, 1, 1) == "/" then return relative_path end

								--     local path = string.gsub(base_path, "[^/]*$", "")

								--     path = path .. relative_path

								--     path = string.gsub(path, "([^/]*%./)", function (s)

								--         if s ~= "./" then return s else return "" end

								--     end)

								--     path = string.gsub(path, "/%.$", "/")

								--     local reduced

								--     while reduced ~= path do

								--         reduced = path

								--         path = string.gsub(reduced, "([^/]*/%.%./)", function (s)

								--             if s ~= "../../" then return "" else return s end

								--         end)

								--     end

								--     path = string.gsub(reduced, "([^/]*/%.%.)$", function (s)

								--         if s ~= "../.." then return "" else return s end

								--     end)

								--     return path

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Parses a url and returns a table with all its parts according to RFC 2396

								-- -- The following grammar describes the names given to the URL parts

								-- -- <url> ::= <scheme>://<authority>/<path>;<params>?<query>#<fragment>

								-- -- <authority> ::= <userinfo>@<host>:<port>

								-- -- <userinfo> ::= <user>[:<password>]

								-- -- <path> :: = {<segment>/}<segment>

								-- -- Input

								-- --   url: uniform resource locator of request

								-- --   default: table with default values for each field

								-- -- Returns

								-- --   table with the following fields, where RFC naming conventions have

								-- --   been preserved:

								-- --     scheme, authority, userinfo, user, password, host, port,

								-- --     path, params, query, fragment

								-- -- Obs:

								-- --   the leading '/' in {/<path>} is considered part of <path>

								-- -----------------------------------------------------------------------------

								-- function _M.parse(url, default)

								--     -- initialize default parameters

								--     local parsed = {}

								--     for i,v in base.pairs(default or parsed) do parsed[i] = v end

								--     -- empty url is parsed to nil

								--     if not url or url == "" then return nil, "invalid url" end

								--     -- remove whitespace

								--     -- url = string.gsub(url, "%s", "")

								--     -- get fragment

								--     url = string.gsub(url, "#(.*)$", function(f)

								--         parsed.fragment = f

								--         return ""

								--     end)

								--     -- get scheme

								--     url = string.gsub(url, "^([%w][%w%+%-%.]*)%:",

								--         function(s) parsed.scheme = s; return "" end)

								--     -- get authority

								--     url = string.gsub(url, "^//([^/]*)", function(n)

								--         parsed.authority = n

								--         return ""

								--     end)

								--     -- get query string

								--     url = string.gsub(url, "%?(.*)", function(q)

								--         parsed.query = q

								--         return ""

								--     end)

								--     -- get params

								--     url = string.gsub(url, "%;(.*)", function(p)

								--         parsed.params = p

								--         return ""

								--     end)

								--     -- path is whatever was left

								--     if url ~= "" then parsed.path = url end

								--     local authority = parsed.authority

								--     if not authority then return parsed end

								--     authority = string.gsub(authority,"^([^@]*)@",

								--         function(u) parsed.userinfo = u; return "" end)

								--     authority = string.gsub(authority, ":([^:%]]*)$",

								--         function(p) parsed.port = p; return "" end)

								--     if authority ~= "" then

								--         -- IPv6?

								--         parsed.host = string.match(authority, "^%[(.+)%]$") or authority

								--     end

								--     local userinfo = parsed.userinfo

								--     if not userinfo then return parsed end

								--     userinfo = string.gsub(userinfo, ":([^:]*)$",

								--         function(p) parsed.password = p; return "" end)

								--     parsed.user = userinfo

								--     return parsed

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Rebuilds a parsed URL from its components.

								-- -- Components are protected if any reserved or unallowed characters are found

								-- -- Input

								-- --   parsed: parsed URL, as returned by parse

								-- -- Returns

								-- --   a stringing with the corresponding URL

								-- -----------------------------------------------------------------------------

								-- function _M.build(parsed)

								--     local ppath = _M.parse_path(parsed.path or "")

								--     local url = _M.build_path(ppath)

								--     if parsed.params then url = url .. ";" .. parsed.params end

								--     if parsed.query then url = url .. "?" .. parsed.query end

								--     local authority = parsed.authority

								--     if parsed.host then

								--         authority = parsed.host

								--         if string.find(authority, ":") then -- IPv6?

								--             authority = "[" .. authority .. "]"

								--         end

								--         if parsed.port then authority = authority .. ":" .. parsed.port end

								--         local userinfo = parsed.userinfo

								--         if parsed.user then

								--             userinfo = parsed.user

								--             if parsed.password then

								--                 userinfo = userinfo .. ":" .. parsed.password

								--             end

								--         end

								--         if userinfo then authority = userinfo .. "@" .. authority end

								--     end

								--     if authority then url = "//" .. authority .. url end

								--     if parsed.scheme then url = parsed.scheme .. ":" .. url end

								--     if parsed.fragment then url = url .. "#" .. parsed.fragment end

								--     -- url = string.gsub(url, "%s", "")

								--     return url

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Builds a absolute URL from a base and a relative URL according to RFC 2396

								-- -- Input

								-- --   base_url

								-- --   relative_url

								-- -- Returns

								-- --   corresponding absolute url

								-- -----------------------------------------------------------------------------

								-- function _M.absolute(base_url, relative_url)

								--     local base_parsed

								--     if base.type(base_url) == "table" then

								--         base_parsed = base_url

								--         base_url = _M.build(base_parsed)

								--     else

								--         base_parsed = _M.parse(base_url)

								--     end

								--     local relative_parsed = _M.parse(relative_url)

								--     if not base_parsed then return relative_url

								--     elseif not relative_parsed then return base_url

								--     elseif relative_parsed.scheme then return relative_url

								--     else

								--         relative_parsed.scheme = base_parsed.scheme

								--         if not relative_parsed.authority then

								--             relative_parsed.authority = base_parsed.authority

								--             if not relative_parsed.path then

								--                 relative_parsed.path = base_parsed.path

								--                 if not relative_parsed.params then

								--                     relative_parsed.params = base_parsed.params

								--                     if not relative_parsed.query then

								--                         relative_parsed.query = base_parsed.query

								--                     end

								--                 end

								--             else

								--                 relative_parsed.path = absolute_path(base_parsed.path or "",

								--                     relative_parsed.path)

								--             end

								--         end

								--         return _M.build(relative_parsed)

								--     end

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Breaks a path into its segments, unescaping the segments

								-- -- Input

								-- --   path

								-- -- Returns

								-- --   segment: a table with one entry per segment

								-- -----------------------------------------------------------------------------

								-- function _M.parse_path(path)

								--     local parsed = {}

								--     path = path or ""

								--     --path = string.gsub(path, "%s", "")

								--     string.gsub(path, "([^/]+)", function (s) table.insert(parsed, s) end)

								--     for i = 1, #parsed do

								--         parsed[i] = _M.unescape(parsed[i])

								--     end

								--     if string.sub(path, 1, 1) == "/" then parsed.is_absolute = 1 end

								--     if string.sub(path, -1, -1) == "/" then parsed.is_directory = 1 end

								--     return parsed

								-- end


								-- -----------------------------------------------------------------------------

								-- -- Builds a path component from its segments, escaping protected characters.

								-- -- Input

								-- --   parsed: path segments

								-- --   unsafe: if true, segments are not protected before path is built

								-- -- Returns

								-- --   path: corresponding path stringing

								-- -----------------------------------------------------------------------------

								-- function _M.build_path(parsed, unsafe)

								--     local path = ""

								--     local n = #parsed

								--     if unsafe then

								--         for i = 1, n-1 do

								--             path = path .. parsed[i]

								--             path = path .. "/"

								--         end

								--         if n > 0 then

								--             path = path .. parsed[n]

								--             if parsed.is_directory then path = path .. "/" end

								--         end

								--     else

								--         for i = 1, n-1 do

								--             path = path .. protect_segment(parsed[i])

								--             path = path .. "/"

								--         end

								--         if n > 0 then

								--             path = path .. protect_segment(parsed[n])

								--             if parsed.is_directory then path = path .. "/" end

								--         end

								--     end

								--     if parsed.is_absolute then path = "/" .. path end

								--     return path

								-- end


								-- return _M