nano-safe-sys 0.0.1

data/yard-0.9.44/lib/yard/server/commands/static_file_helpers.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module YARD
+  module Server
+    module Commands
+      # Include this module to get access to {#static_template_file?}
+      # and {favicon?} helpers.
+      module StaticFileHelpers
+        include Server::HTTPUtils
+
+        # Serves an empty favicon.
+        # @raise [FinishRequest] finalizes an empty body if the path matches
+        #   /favicon.ico so browsers don't complain.
+        def favicon?
+          return unless request.path == '/favicon.ico'
+          headers['Content-Type'] = 'image/png'
+          self.status = 200
+          self.body = ''
+          raise FinishRequest
+        end
+
+        # Attempts to route a path to a static template file.
+        #
+        # @raise [FinishRequest] if a file was found and served
+        # @return [void]
+        def static_template_file?
+          # this const was defined in StaticFileCommand originally
+          default_mime_types = StaticFileCommand::DefaultMimeTypes
+
+          file = find_file(adapter, path)
+
+          if file
+            ext = "." + (path[/\.(\w+)$/, 1] || "html")
+            headers['Content-Type'] = mime_type(ext, default_mime_types)
+            self.body = File.read(file)
+            raise FinishRequest
+          end
+        end
+
+        module_function
+
+        def find_file(adapter, url)
+          # this const was defined in StaticFileCommand originally
+          static_paths = StaticFileCommand::STATIC_PATHS
+
+          file = nil
+          ([adapter.document_root] + static_paths.reverse).compact.each do |path_prefix|
+            file = File.join(path_prefix, url)
+            break if File.exist?(file)
+            file = nil
+          end
+
+          # Search in default/fulldoc/html template if nothing in static asset paths
+          assets_template = Templates::Engine.template(:default, :fulldoc, :html)
+          file || assets_template.find_file(url)
+        end
+      end
+    end
+  end
+end

data/yard-0.9.44/lib/yard/server/doc_server_helper.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    # A module that is mixed into {Templates::Template} in order to customize
+    # certain template methods.
+    module DocServerHelper
+      # Modifies {Templates::Helpers::HtmlHelper#url_for} to return a URL instead
+      # of a disk location.
+      # @param (see Templates::Helpers::HtmlHelper#url_for)
+      # @return (see Templates::Helpers::HtmlHelper#url_for)
+      def url_for(obj, anchor = nil, relative = false) # rubocop:disable Lint/UnusedMethodArgument
+        return '' if obj.nil?
+        return url_for_index if obj == '_index.html'
+        return abs_url(base_path(router.static_prefix), obj) if String === obj
+        url = super(obj, anchor, false)
+        return unless url
+        abs_url(base_path(router.docs_prefix), url)
+      end
+
+      # Modifies {Templates::Helpers::HtmlHelper#url_for_file} to return a URL instead
+      # of a disk location.
+      # @param (see Templates::Helpers::HtmlHelper#url_for_file)
+      # @return (see Templates::Helpers::HtmlHelper#url_for_file)
+      def url_for_file(filename, anchor = nil)
+        if filename.is_a?(CodeObjects::ExtraFileObject)
+          filename = filename.filename
+        end
+        fname = filename.sub(%r{^#{@library.source_path.to_s}/}, '')
+        fname += "##{anchor}" if anchor && !anchor.empty?
+        abs_url(base_path(router.docs_prefix), 'file', fname)
+      end
+
+      # Modifies {Templates::Helpers::HtmlHelper#url_for_list} to return a URL
+      # based on the list prefix instead of a HTML filename.
+      # @param (see Templates::Helpers::HtmlHelper#url_for_list)
+      # @return (see Templates::Helpers::HtmlHelper#url_for_list)
+      def url_for_list(type)
+        abs_url(base_path(router.list_prefix), type.to_s)
+      end
+
+      # Returns the frames URL for the page
+      # @return (see Templates::Helpers::HtmlHelper#url_for_frameset)
+      def url_for_frameset
+        options.file ? url_for_file(options.file) : url_for(object)
+      end
+
+      # Returns the main URL, first checking a readme and then linking to the index
+      # @return (see Templates::Helpers::HtmlHelper#url_for_main)
+      def url_for_main
+        options.readme ? url_for_file(options.readme) : url_for_index
+      end
+
+      # Returns the URL for the alphabetic index page
+      # @return (see Templates::Helpers::HtmlHelper#url_for_index)
+      def url_for_index
+        abs_url(base_path(router.docs_prefix), 'index')
+      end
+
+      # @param path_components [Array<String>] components of a URL
+      # @return [String] the absolute path from any mounted base URI.
+      def abs_url(*path_components)
+        File.join(router.request.script_name, *path_components)
+      end
+
+      # @example The base path for a library 'foo'
+      #   base_path('docs') # => 'docs/foo'
+      # @param [String] path the path prefix for a base path URI
+      # @return [String] the base URI for a library with an extra +path+ prefix
+      def base_path(path)
+        libname = router.request.version_supplied ? @library.to_s : @library.name
+        path + (@single_library ? '' : "/#{libname}")
+      end
+
+      # @return [Router] convenience method for accessing the router
+      def router; @adapter.router end
+
+      # @return [String] a timestamp for a given file
+      def mtime(file)
+        file = YARD::Server::Commands::StaticFileHelpers.find_file(@adapter, file)
+        file ? File.mtime(file).to_i : nil
+      end
+
+      # @return [String] a URL for a file with a timestamp
+      def mtime_url(file)
+        url = url_for(file)
+        time = mtime(file)
+        url + (time ? "?#{time}" : "")
+      end
+    end
+  end
+end

data/yard-0.9.44/lib/yard/server/doc_server_serializer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    # A custom {Serializers::Base serializer} which returns resource URLs instead of
+    # static relative paths to files on disk.
+    class DocServerSerializer < Serializers::FileSystemSerializer
+      def initialize(_command = nil)
+        super(:basepath => '', :extension => '')
+      end
+
+      def serialized_path(object)
+        case object
+        when CodeObjects::RootObject
+          "toplevel"
+        when CodeObjects::ExtendedMethodObject
+          serialized_path(object.namespace) + ':' + urlencode(object.name.to_s)
+        when CodeObjects::MethodObject
+          serialized_path(object.namespace) +
+            (object.scope == :instance ? ":" : ".") + urlencode(object.name.to_s)
+        when CodeObjects::ConstantObject, CodeObjects::ClassVariableObject
+          serialized_path(object.namespace) + "##{object.name}-#{object.type}"
+        when CodeObjects::ExtraFileObject
+          super(object).gsub(/^file\./, 'file/')
+        else
+          super(object)
+        end
+      end
+
+      private
+
+      def urlencode(name)
+        if name.respond_to?(:force_encoding)
+          name = name.dup.force_encoding('binary')
+        end
+        Templates::Helpers::HtmlHelper.urlencode(name)
+      end
+    end
+  end
+end

data/yard-0.9.44/lib/yard/server/http_utils.rb

@@ -0,0 +1,512 @@
+# frozen_string_literal: false
+#
+# httputils.rb -- HTTPUtils Module
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: httputils.rb,v 1.34 2003/06/05 21:34:08 gotoyuzo Exp $
+
+require 'socket'
+require 'tempfile'
+
+module YARD::Server
+  CR   = "\x0d"     # :nodoc:
+  LF   = "\x0a"     # :nodoc:
+  CRLF = "\x0d\x0a" # :nodoc:
+
+  ##
+  # HTTPUtils provides utility methods for working with the HTTP protocol.
+  #
+  # This module is generally used internally by WEBrick
+
+  module HTTPUtils
+
+    ##
+    # Normalizes a request path.  Raises an exception if the path cannot be
+    # normalized.
+
+    def normalize_path(path)
+      raise "abnormal path `#{path}'" if path[0] != ?/
+      ret = path.dup
+
+      ret.gsub!(%r{/+}o, '/')                    # //      => /
+      while ret.sub!(%r'/\.(?:/|\Z)', '/'); end  # /.      => /
+      while ret.sub!(%r'/(?!\.\./)[^/]+/\.\.(?:/|\Z)', '/'); end # /foo/.. => /foo
+
+      raise "abnormal path `#{path}'" if %r{/\.\.(/|\Z)} =~ ret
+      ret
+    end
+    module_function :normalize_path
+
+    ##
+    # Default mime types
+
+    DefaultMimeTypes = {
+      "ai"    => "application/postscript",
+      "asc"   => "text/plain",
+      "avi"   => "video/x-msvideo",
+      "bin"   => "application/octet-stream",
+      "bmp"   => "image/bmp",
+      "class" => "application/octet-stream",
+      "cer"   => "application/pkix-cert",
+      "crl"   => "application/pkix-crl",
+      "crt"   => "application/x-x509-ca-cert",
+     #"crl"   => "application/x-pkcs7-crl",
+      "css"   => "text/css",
+      "dms"   => "application/octet-stream",
+      "doc"   => "application/msword",
+      "dvi"   => "application/x-dvi",
+      "eps"   => "application/postscript",
+      "etx"   => "text/x-setext",
+      "exe"   => "application/octet-stream",
+      "gif"   => "image/gif",
+      "htm"   => "text/html",
+      "html"  => "text/html",
+      "jpe"   => "image/jpeg",
+      "jpeg"  => "image/jpeg",
+      "jpg"   => "image/jpeg",
+      "js"    => "application/javascript",
+      "json"  => "application/json",
+      "lha"   => "application/octet-stream",
+      "lzh"   => "application/octet-stream",
+      "mjs"   => "application/javascript",
+      "mov"   => "video/quicktime",
+      "mpe"   => "video/mpeg",
+      "mpeg"  => "video/mpeg",
+      "mpg"   => "video/mpeg",
+      "pbm"   => "image/x-portable-bitmap",
+      "pdf"   => "application/pdf",
+      "pgm"   => "image/x-portable-graymap",
+      "png"   => "image/png",
+      "pnm"   => "image/x-portable-anymap",
+      "ppm"   => "image/x-portable-pixmap",
+      "ppt"   => "application/vnd.ms-powerpoint",
+      "ps"    => "application/postscript",
+      "qt"    => "video/quicktime",
+      "ras"   => "image/x-cmu-raster",
+      "rb"    => "text/plain",
+      "rd"    => "text/plain",
+      "rtf"   => "application/rtf",
+      "sgm"   => "text/sgml",
+      "sgml"  => "text/sgml",
+      "svg"   => "image/svg+xml",
+      "tif"   => "image/tiff",
+      "tiff"  => "image/tiff",
+      "txt"   => "text/plain",
+      "wasm"  => "application/wasm",
+      "xbm"   => "image/x-xbitmap",
+      "xhtml" => "text/html",
+      "xls"   => "application/vnd.ms-excel",
+      "xml"   => "text/xml",
+      "xpm"   => "image/x-xpixmap",
+      "xwd"   => "image/x-xwindowdump",
+      "zip"   => "application/zip",
+    }
+
+    ##
+    # Loads Apache-compatible mime.types in +file+.
+
+    def load_mime_types(file)
+      # note: +file+ may be a "| command" for now; some people may
+      # rely on this, but currently we do not use this method by default.
+      open(file){ |io|
+        hash = Hash.new
+        io.each{ |line|
+          next if /^#/ =~ line
+          line.chomp!
+          mimetype, ext0 = line.split(/\s+/, 2)
+          next unless ext0
+          next if ext0.empty?
+          ext0.split(/\s+/).each{ |ext| hash[ext] = mimetype }
+        }
+        hash
+      }
+    end
+    module_function :load_mime_types
+
+    ##
+    # Returns the mime type of +filename+ from the list in +mime_tab+.  If no
+    # mime type was found application/octet-stream is returned.
+
+    def mime_type(filename, mime_tab)
+      suffix1 = (/\.(\w+)$/ =~ filename && $1.downcase)
+      suffix2 = (/\.(\w+)\.[\w\-]+$/ =~ filename && $1.downcase)
+      mime_tab[suffix1] || mime_tab[suffix2] || "application/octet-stream"
+    end
+    module_function :mime_type
+
+    ##
+    # Parses an HTTP header +raw+ into a hash of header fields with an Array
+    # of values.
+
+    def parse_header(raw)
+      header = Hash.new([].freeze)
+      field = nil
+      raw.each_line{|line|
+        case line
+        when /^([A-Za-z0-9!\#$%&'*+\-.^_`|~]+):\s*(.*?)\s*\z/om
+          field, value = $1, $2
+          field.downcase!
+          header[field] = [] unless header.has_key?(field)
+          header[field] << value
+        when /^\s+(.*?)\s*\z/om
+          value = $1
+          unless field
+            raise HTTPStatus::BadRequest, "bad header '#{line}'."
+          end
+          header[field][-1] << " " << value
+        else
+          raise HTTPStatus::BadRequest, "bad header '#{line}'."
+        end
+      }
+      header.each{|key, values|
+        values.each(&:strip!)
+      }
+      header
+    end
+    module_function :parse_header
+
+    ##
+    # Splits a header value +str+ according to HTTP specification.
+
+    def split_header_value(str)
+      str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
+                    (?:,\s*|\Z)'xn).flatten
+    end
+    module_function :split_header_value
+
+    ##
+    # Parses a Range header value +ranges_specifier+
+
+    def parse_range_header(ranges_specifier)
+      if /^bytes=(.*)/ =~ ranges_specifier
+        byte_range_set = split_header_value($1)
+        byte_range_set.collect{|range_spec|
+          case range_spec
+          when /^(\d+)-(\d+)/ then $1.to_i .. $2.to_i
+          when /^(\d+)-/      then $1.to_i .. -1
+          when /^-(\d+)/      then -($1.to_i) .. -1
+          else return nil
+          end
+        }
+      end
+    end
+    module_function :parse_range_header
+
+    ##
+    # Parses q values in +value+ as used in Accept headers.
+
+    def parse_qvalues(value)
+      tmp = []
+      if value
+        parts = value.split(/,\s*/)
+        parts.each {|part|
+          if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
+            val = m[1]
+            q = (m[2] or 1).to_f
+            tmp.push([val, q])
+          end
+        }
+        tmp = tmp.sort_by{|val, q| -q}
+        tmp.collect!{|val, q| val}
+      end
+      return tmp
+    end
+    module_function :parse_qvalues
+
+    ##
+    # Removes quotes and escapes from +str+
+
+    def dequote(str)
+      ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
+      ret.gsub!(/\\(.)/, "\\1")
+      ret
+    end
+    module_function :dequote
+
+    ##
+    # Quotes and escapes quotes in +str+
+
+    def quote(str)
+      '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
+    end
+    module_function :quote
+
+    ##
+    # Stores multipart form data.  FormData objects are created when
+    # WEBrick::HTTPUtils.parse_form_data is called.
+
+    class FormData < String
+      EmptyRawHeader = [].freeze # :nodoc:
+      EmptyHeader = {}.freeze # :nodoc:
+
+      ##
+      # The name of the form data part
+
+      attr_accessor :name
+
+      ##
+      # The filename of the form data part
+
+      attr_accessor :filename
+
+      attr_accessor :next_data # :nodoc:
+      protected :next_data
+
+      ##
+      # Creates a new FormData object.
+      #
+      # +args+ is an Array of form data entries.  One FormData will be created
+      # for each entry.
+      #
+      # This is called by WEBrick::HTTPUtils.parse_form_data for you
+
+      def initialize(*args)
+        @name = @filename = @next_data = nil
+        if args.empty?
+          @raw_header = []
+          @header = nil
+          super("")
+        else
+          @raw_header = EmptyRawHeader
+          @header = EmptyHeader
+          super(args.shift)
+          unless args.empty?
+            @next_data = self.class.new(*args)
+          end
+        end
+      end
+
+      ##
+      # Retrieves the header at the first entry in +key+
+
+      def [](*key)
+        begin
+          @header[key[0].downcase].join(", ")
+        rescue StandardError, NameError
+          super
+        end
+      end
+
+      ##
+      # Adds +str+ to this FormData which may be the body, a header or a
+      # header entry.
+      #
+      # This is called by WEBrick::HTTPUtils.parse_form_data for you
+
+      def <<(str)
+        if @header
+          super
+        elsif str == CRLF
+          @header = HTTPUtils::parse_header(@raw_header.join)
+          if cd = self['content-disposition']
+            if /\s+name="(.*?)"/ =~ cd then @name = $1 end
+            if /\s+filename="(.*?)"/ =~ cd then @filename = $1 end
+          end
+        else
+          @raw_header << str
+        end
+        self
+      end
+
+      ##
+      # Adds +data+ at the end of the chain of entries
+      #
+      # This is called by WEBrick::HTTPUtils.parse_form_data for you.
+
+      def append_data(data)
+        tmp = self
+        while tmp
+          unless tmp.next_data
+            tmp.next_data = data
+            break
+          end
+          tmp = tmp.next_data
+        end
+        self
+      end
+
+      ##
+      # Yields each entry in this FormData
+
+      def each_data
+        tmp = self
+        while tmp
+          next_data = tmp.next_data
+          yield(tmp)
+          tmp = next_data
+        end
+      end
+
+      ##
+      # Returns all the FormData as an Array
+
+      def list
+        ret = []
+        each_data{|data|
+          ret << data.to_s
+        }
+        ret
+      end
+
+      ##
+      # A FormData will behave like an Array
+
+      alias :to_ary :list
+
+      ##
+      # This FormData's body
+
+      def to_s
+        String.new(self)
+      end
+    end
+
+    ##
+    # Parses the query component of a URI in +str+
+
+    def parse_query(str)
+      query = Hash.new
+      if str
+        str.split(/[&;]/).each{|x|
+          next if x.empty?
+          key, val = x.split(/=/,2)
+          key = unescape_form(key)
+          val = unescape_form(val.to_s)
+          val = FormData.new(val)
+          val.name = key
+          if query.has_key?(key)
+            query[key].append_data(val)
+            next
+          end
+          query[key] = val
+        }
+      end
+      query
+    end
+    module_function :parse_query
+
+    ##
+    # Parses form data in +io+ with the given +boundary+
+
+    def parse_form_data(io, boundary)
+      boundary_regexp = /\A--#{Regexp.quote(boundary)}(--)?#{CRLF}\z/
+      form_data = Hash.new
+      return form_data unless io
+      data = nil
+      io.each_line{|line|
+        if boundary_regexp =~ line
+          if data
+            data.chop!
+            key = data.name
+            if form_data.has_key?(key)
+              form_data[key].append_data(data)
+            else
+              form_data[key] = data
+            end
+          end
+          data = FormData.new
+          next
+        else
+          if data
+            data << line
+          end
+        end
+      }
+      return form_data
+    end
+    module_function :parse_form_data
+
+    #####
+
+    reserved = ';/?:@&=+$,'
+    num      = '0123456789'
+    lowalpha = 'abcdefghijklmnopqrstuvwxyz'
+    upalpha  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    mark     = '-_.!~*\'()'
+    unreserved = num + lowalpha + upalpha + mark
+    control  = (0x0..0x1f).collect{|c| c.chr }.join + "\x7f"
+    space    = " "
+    delims   = '<>#%"'
+    unwise   = '{}|\\^[]`'
+    nonascii = (0x80..0xff).collect{|c| c.chr }.join
+
+    module_function
+
+    # :stopdoc:
+
+    def _make_regex(str) /([#{Regexp.escape(str)}])/n end
+    def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end
+    def _escape(str, regex)
+      str = str.b
+      str.gsub!(regex) {"%%%02X" % $1.ord}
+      # %-escaped string should contain US-ASCII only
+      str.force_encoding(Encoding::US_ASCII)
+    end
+    def _unescape(str, regex)
+      str = str.b
+      str.gsub!(regex) {$1.hex.chr}
+      # encoding of %-unescaped string is unknown
+      str
+    end
+
+    UNESCAPED = _make_regex(control+space+delims+unwise+nonascii)
+    UNESCAPED_FORM = _make_regex(reserved+control+delims+unwise+nonascii)
+    NONASCII  = _make_regex(nonascii)
+    ESCAPED   = /%([0-9a-fA-F]{2})/
+    UNESCAPED_PCHAR = _make_regex!(unreserved+":@&=+$,")
+
+    # :startdoc:
+
+    ##
+    # Escapes HTTP reserved and unwise characters in +str+
+
+    def escape(str)
+      _escape(str, UNESCAPED)
+    end
+
+    ##
+    # Unescapes HTTP reserved and unwise characters in +str+
+
+    def unescape(str)
+      _unescape(str, ESCAPED)
+    end
+
+    ##
+    # Escapes form reserved characters in +str+
+
+    def escape_form(str)
+      ret = _escape(str, UNESCAPED_FORM)
+      ret.gsub!(/ /, "+")
+      ret
+    end
+
+    ##
+    # Unescapes form reserved characters in +str+
+
+    def unescape_form(str)
+      _unescape(str.gsub(/\+/, " "), ESCAPED)
+    end
+
+    ##
+    # Escapes path +str+
+
+    def escape_path(str)
+      result = ""
+      str.scan(%r{/([^/]*)}).each{|i|
+        result << "/" << _escape(i[0], UNESCAPED_PCHAR)
+      }
+      return result
+    end
+
+    ##
+    # Escapes 8 bit characters in +str+
+
+    def escape8bit(str)
+      _escape(str, NONASCII)
+    end
+  end
+end