hyper-pro-gem 0.0.1

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+require 'fileutils'
+require 'thread'
+
+module YARD
+  module Server
+    # This exception is raised when {LibraryVersion#prepare!} fails, or discovers
+    # that the library is not "prepared" to be served by
+    class LibraryNotPreparedError < RuntimeError; end
+
+    # A library version encapsulates a library's documentation at a specific version.
+    # Although the version is optional, this allows for creating multiple documentation
+    # points for a specific library, each representing a unique version. The term
+    # "library" used in other parts of the YARD::Server documentation refers to
+    # objects of this class unless otherwise noted.
+    #
+    # A library points to a location where a {#yardoc_file} is located so that
+    # its documentation may be loaded and served. Optionally, a {#source_path} is
+    # given to point to a location where any extra files (and {YARD::CLI::Yardoc .yardopts})
+    # should be loaded from. Both of these methods may not be known immediately,
+    # since the yardoc file may not be built until later. Resolving the yardoc
+    # file and source path are dependent on the specific library "source type" used.
+    # Source types (known as "library source") are discussed in detail below.
+    #
+    # == Using with Adapters
+    # A list of libraries need to be passed into adapters upon creation. In
+    # most cases, you will never do this manually, but if you use a {RackMiddleware},
+    # you will need to pass in this list yourself. To build this list of libraries,
+    # you should create a hash of library names mapped to an *Array* of LibraryVersion
+    # objects. For example:
+    #
+    #   {'mylib' => [LibraryVersion.new('mylib', '1.0', ...),
+    #                LibraryVersion.new('mylib', '2.0', ...)]}
+    #
+    # Note that you can also use {Adapter#add_library} for convenience.
+    #
+    # The "array" part is required, even for just one library version.
+    #
+    # == Library Sources
+    # The {#source} method represents the library source type, ie. where the
+    # library "comes from". It might come from "disk", or it might come from a
+    # "gem" (technically the disk, but a separate type nonetheless). In these
+    # two cases, the yardoc file sits somewhere on your filesystem, though
+    # it may also be built dynamically if it does not yet exist. This behaviour
+    # is controlled through the {#prepare!} method, which prepares the yardoc file
+    # given a specific library source. We will see how this works in detail in
+    # the following section.
+    #
+    # == Implementing a Custom Library Source
+    # YARD can be extended to support custom library sources in order to
+    # build or retrieve a yardoc file at runtime from many different locations.
+    #
+    # To implement this behaviour, 3 methods can be added to the +LibraryVersion+
+    # class, +#load_yardoc_from_SOURCE+, +#yardoc_file_for_SOURCE+, and
+    # +#source_path_for_SOURCE+. In all cases, "SOURCE" represents the source
+    # type used in {#source} when creating the library object. The
+    # +#yardoc_file_for_SOURCE+ and +#source_path_for_SOURCE+ methods are called upon
+    # creation and should return the location where the source code for the library
+    # lives. The load method is called from {#prepare!} if there is no yardoc file
+    # and should set {#yardoc_file}. Below is a full example for
+    # implementing a custom library source, +:http+, which reads packaged .yardoc
+    # databases from zipped archives off of an HTTP server.
+    #
+    # Note that only +#load_yardoc_from_SOURCE+ is required. The other two
+    # methods are optional and can be set manually (via {#source_path=} and
+    # {#yardoc_file=}) on the object at any time.
+    #
+    # @example Implementing a Custom Library Source
+    #   # Adds the source type "http" for .yardoc files zipped on HTTP servers
+    #   class LibraryVersion
+    #     def load_yardoc_from_http
+    #       Thread.new do
+    #         # zip/unzip method implementations are not shown
+    #         download_zip_file("https://mysite.com/yardocs/#{self}.zip")
+    #         unzip_file_to("/path/to/yardocs/#{self}")
+    #       end
+    #
+    #       # tell the server it's not ready yet (but it might be next time)
+    #       raise LibraryNotPreparedError
+    #     end
+    #
+    #     def yardoc_file_for_http
+    #       "/path/to/yardocs/#{self}/.yardoc"
+    #     end
+    #
+    #     def source_path_for_http
+    #       File.dirname(yardoc_file)
+    #     end
+    #   end
+    #
+    #   # Creating a library of this source type:
+    #   LibraryVersion.new('name', '1.0', nil, :http)
+    #
+    class LibraryVersion
+      # @return [String] the name of the library
+      attr_accessor :name
+
+      # @return [String] the version of the specific library
+      attr_accessor :version
+
+      # @return [String] the location of the yardoc file used to load the object
+      #   information from.
+      # @return [nil] if no yardoc file exists yet. In this case, {#prepare!} will
+      #   be called on this library to build the yardoc file.
+      # @note To implement a custom yardoc file getter, implement
+      def yardoc_file
+        @yardoc_file ||= load_yardoc_file
+      end
+      attr_writer :yardoc_file
+
+      # @return [Symbol] the source type representing where the yardoc should be
+      #   loaded from. Defaults are +:disk+ and +:gem+, though custom sources
+      #   may be implemented. This value is used to inform {#prepare!} about how
+      #   to load the necessary data in order to display documentation for an object.
+      # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+      attr_accessor :source
+
+      # @return [String] the location of the source code for a library. This
+      #   value is filled by calling +#source_path_for_SOURCE+ on this class.
+      # @return [nil] if there is no source code
+      # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+      def source_path
+        @source_path ||= load_source_path
+      end
+      attr_writer :source_path
+
+      # @param [String] name the name of the library
+      # @param [String] version the specific (usually, but not always, numeric) library
+      #   version
+      # @param [String] yardoc the location of the yardoc file, or nil if it is
+      #   generated later
+      # @param [Symbol] source the location of the files used to build the yardoc.
+      #   Builtin source types are +:disk+ or +:gem+.
+      def initialize(name, version = nil, yardoc = nil, source = :disk)
+        self.name = name
+        self.yardoc_file = yardoc
+        self.version = version
+        self.source = source
+      end
+
+      # @param [Boolean] url_format if true, returns the string in a URI-compatible
+      #   format (for appending to a URL). Otherwise, it is given in a more human
+      #   readable format.
+      # @return [String] the string representation of the library.
+      def to_s(url_format = true)
+        version ? "#{name}#{url_format ? '/' : '-'}#{version}" : name.to_s
+      end
+
+      # @return [Fixnum] used for Hash mapping.
+      def hash; to_s.hash end
+
+      # @return [Boolean] whether another LibraryVersion is equal to this one
+      def eql?(other)
+        other.is_a?(LibraryVersion) && other.name == name &&
+          other.version == version && other.yardoc_file == yardoc_file
+      end
+      alias == eql?
+      alias equal? eql?
+
+      # @return [Boolean] whether the library has been completely processed
+      #   and is ready to be served
+      def ready?
+        return false if yardoc_file.nil?
+        serializer.complete?
+      end
+
+      # @note You should not directly override this method. Instead, implement
+      #   +load_yardoc_from_SOURCENAME+ when implementing loading for a specific
+      #   source type. See the {LibraryVersion} documentation for "Implementing
+      #   a Custom Library Source"
+      #
+      # Prepares a library to be displayed by the server. This callback is
+      # performed before each request on a library to ensure that it is loaded
+      # and ready to be viewed. If any steps need to be performed prior to loading,
+      # they are performed through this method (though they should be implemented
+      # through the +load_yardoc_from_SOURCE+ method).
+      #
+      # @raise [LibraryNotPreparedError] if the library is not ready to be
+      #   displayed. Usually when raising this error, you would simultaneously
+      #   begin preparing the library for subsequent requests, although this
+      #   is not necessary.
+      def prepare!
+        return if ready?
+        meth = "load_yardoc_from_#{source}"
+        send(meth) if respond_to?(meth, true)
+      end
+
+      # @return [Gem::Specification] a gemspec object for a given library. Used
+      #   for :gem source types.
+      # @return [nil] if there is no installed gem for the library
+      def gemspec
+        ver = version ? "= #{version}" : ">= 0"
+        YARD::GemIndex.find_all_by_name(name, ver).last
+      end
+
+      protected
+
+      @@chdir_mutex = Mutex.new
+
+      # Called when a library of source type "disk" is to be prepared. In this
+      # case, the {#yardoc_file} should already be set, but the library may not
+      # be prepared. Run preparation if not done.
+      #
+      # @raise [LibraryNotPreparedError] if the yardoc file has not been
+      #   prepared.
+      def load_yardoc_from_disk
+        return if ready?
+
+        @@chdir_mutex.synchronize do
+          Dir.chdir(source_path_for_disk) do
+            Thread.new do
+              CLI::Yardoc.run('--no-stats', '-n', '-b', yardoc_file)
+            end
+          end
+        end
+
+        raise LibraryNotPreparedError
+      end
+
+      # Called when a library of source type "gem" is to be prepared. In this
+      # case, the {#yardoc_file} needs to point to the correct location for
+      # the installed gem. The yardoc file is built if it has not been done.
+      #
+      # @raise [LibraryNotPreparedError] if the gem does not have an existing
+      #   yardoc file.
+      def load_yardoc_from_gem
+        return if ready?
+        ver = version ? "= #{version}" : ">= 0"
+
+        @@chdir_mutex.synchronize do
+          Thread.new do
+            # Build gem docs on demand
+            log.debug "Building gem docs for #{to_s(false)}"
+            CLI::Gems.run(name, ver)
+            log.debug "Done building gem docs for #{to_s(false)}"
+          end
+        end
+
+        raise LibraryNotPreparedError
+      end
+
+      # @return [String] the source path for a disk source
+      def source_path_for_disk
+        File.dirname(yardoc_file) if yardoc_file
+      end
+
+      # @return [String] the source path for a gem source
+      def source_path_for_gem
+        gemspec.full_gem_path if gemspec
+      end
+
+      # @return [String] the yardoc file for a gem source
+      def yardoc_file_for_gem
+        require 'rubygems'
+        ver = version ? "= #{version}" : ">= 0"
+        Registry.yardoc_file_for_gem(name, ver)
+      end
+
+      private
+
+      def load_source_path
+        meth = "source_path_for_#{source}"
+        send(meth) if respond_to?(meth, true)
+      end
+
+      def load_yardoc_file
+        meth = "yardoc_file_for_#{source}"
+        send(meth) if respond_to?(meth, true)
+      end
+
+      def serializer
+        return if yardoc_file.nil?
+        Serializers::YardocSerializer.new(yardoc_file)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module YARD
+  module Server
+    begin
+      require 'rackup'
+      # @private
+      RackServer = Rackup::Server
+    rescue LoadError
+      require 'rack'
+      # @private
+      RackServer = Rack::Server
+    end
+
+    # This class wraps the {RackAdapter} into a Rack-compatible middleware.
+    # See {#initialize} for a list of options to pass via Rack's +#use+ method.
+    #
+    # @note You must pass a +:libraries+ option to the RackMiddleware via +#use+. To
+    #   read about how to return a list of libraries, see {LibraryVersion} or look
+    #   at the example below.
+    # @example Using the RackMiddleware in a Rack application
+    #   libraries = {:mylib => [YARD::Server::LibraryVersion.new('mylib', nil, '/path/to/.yardoc')]}
+    #   use YARD::Server::RackMiddleware, :libraries => libraries
+    #
+    class RackMiddleware
+      # Creates a new Rack-based middleware for serving YARD documentation.
+      #
+      # @param app the next Rack middleware in the stack
+      # @option opts [Hash{String=>Array<LibraryVersion>}] :libraries ({})
+      #   the map of libraries to serve through the adapter. This option is *required*.
+      # @option opts [Hash] :options ({}) a list of options to pass to the adapter.
+      #   See {Adapter#options} for a list.
+      # @option opts [Hash] :server_options ({}) a list of options to pass to the server.
+      #   See {Adapter#server_options} for a list.
+      def initialize(app, opts = {})
+        args = [opts[:libraries] || {}, opts[:options] || {}, opts[:server_options] || {}]
+        @app = app
+        @adapter = RackAdapter.new(*args)
+      end
+
+      def call(env)
+        status, headers, body = *@adapter.call(env)
+        if status == 404
+          @app.call(env)
+        else
+          [status, headers, body]
+        end
+      end
+    end
+
+    # A server adapter to respond to requests using the Rack server infrastructure.
+    class RackAdapter < Adapter
+      include YARD::Server::HTTPUtils
+
+      # Responds to Rack requests and builds a response with the {Router}.
+      # @return [Array(Numeric,Hash,Array)] the Rack-style response
+      def call(env)
+        request = Rack::Request.new(env)
+        request.path_info = unescape(request.path_info) # unescape things like %3F
+        router.call(request)
+      rescue StandardError => ex
+        log.backtrace(ex)
+        [500, {'Content-Type' => 'text/plain'},
+          [ex.message + "\n" + ex.backtrace.join("\n")]]
+      end
+
+      # Starts the Rack server. This method will pass control to the server and
+      # block.
+      # @return [void]
+      def start
+        server = RackServer.new(server_options)
+        server.instance_variable_set("@app", self)
+        print_start_message(server)
+        server.start
+      end
+
+      private
+
+      def print_start_message(server)
+        opts = server.default_options.merge(server.options)
+        log.puts ">> YARD #{YARD::VERSION} documentation server at http://#{opts[:Host]}:#{opts[:Port]}"
+
+        # Only happens for Mongrel
+        return unless server.server.to_s == "Rack::Handler::Mongrel"
+        log.puts ">> #{server.server.class_name} web server (running on Rack)"
+        log.puts ">> Listening on #{opts[:Host]}:#{opts[:Port]}, CTRL+C to stop"
+      end
+    end
+  end
+end
+
+# @private
+class Rack::Request
+  attr_accessor :version_supplied
+  alias query params
+  def xhr?; (env['HTTP_X_REQUESTED_WITH'] || "").casecmp("xmlhttprequest") == 0 end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    # A router class implements the logic used to recognize a request for a specific
+    # URL and run specific {Commands::Base commands}.
+    #
+    # == Subclassing Notes
+    # To create a custom router, subclass this class and pass it into the adapter
+    # options through {Adapter#initialize} or by directly modifying {Adapter#router}.
+    #
+    # The most general customization is to change the URL prefixes recognized by
+    # routing, which can be done by overriding {#docs_prefix}, {#list_prefix},
+    # {#static_prefix}, and {#search_prefix}.
+    #
+    # == Implementing Custom Caching
+    # By default, the Router class performs static disk-based caching on all
+    # requests through the +#check_static_cache+. To override this behaviour,
+    # or create your own caching mechanism, mixin your own custom module with
+    # this method implemented as per {StaticCaching#check_static_cache}.
+    #
+    # @example Creating a subclassed router
+    #   # Adds 'my' to all routing prefixes
+    #   class MyRouter < YARD::Server::Router
+    #     def docs_prefix; 'mydocs' end
+    #     def list_prefix; 'mylist' end
+    #     def static_prefix; 'mystatic' end
+    #     def search_prefix; 'mysearch' end
+    #   end
+    #
+    #   # Using it:
+    #   WebrickAdapter.new(libraries, :router => MyRouter).start
+    class Router
+      include StaticCaching
+      include Commands
+
+      # @return [Adapter Dependent] the request data coming in with the routing
+      attr_accessor :request
+
+      # @return [Adapter] the adapter used by the router
+      attr_accessor :adapter
+
+      # Creates a new router for a specific adapter
+      #
+      # @param [Adapter] adapter the adapter to route requests to
+      def initialize(adapter)
+        self.adapter = adapter
+      end
+
+      # Perform routing on a specific request, serving the request as a static
+      # file through {Commands::RootRequestCommand} if no route is found.
+      #
+      # @param [Adapter Dependent] request the request object
+      # @return [Array(Numeric,Hash,Array)] the Rack-style server response data
+      def call(request)
+        self.request = request
+        result = check_static_cache || route
+        result ? result : RootRequestCommand.new(adapter.options).call(request)
+      end
+
+      # @group Route Prefixes
+
+      # @return [String] the URI prefix for all object documentation requests
+      def docs_prefix; 'docs' end
+
+      # @return [String] the URI prefix for all class/method/file list requests
+      def list_prefix; 'list' end
+
+      # @return [String] the URI prefix for all search requests
+      def search_prefix; 'search' end
+
+      # @return [String] the URI prefix for all static assets (templates)
+      def static_prefix; 'static' end
+
+      # @group Routing Methods
+
+      # @return [Array(LibraryVersion, Array<String>)] the library followed
+      #   by the rest of the path components in the request path. LibraryVersion
+      #   will be nil if no matching library was found.
+      def parse_library_from_path(paths)
+        return [adapter.libraries.values.first.first, paths] if adapter.options[:single_library]
+        library = nil
+        paths = paths.dup
+        libs = adapter.libraries[paths.first]
+        if libs
+          paths.shift
+          library = libs.find {|l| l.version == paths.first }
+          if library
+            request.version_supplied = true if request
+            paths.shift
+          else # use the last lib in the list
+            request.version_supplied = false if request
+            library = libs.last
+          end
+        end
+        [library, paths]
+      end
+
+      protected
+
+      # Performs routing algorithm to find which prefix is called, first
+      # parsing out library name/version information.
+      #
+      # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response
+      # @return [nil] if no route is matched
+      def route(path = request.path_info)
+        path = path.gsub(%r{//+}, '/').gsub(%r{^/|/$}, '')
+        return route_index if path.empty? || path == docs_prefix
+        case path
+        when %r{^(#{docs_prefix}|#{list_prefix}|#{search_prefix}|#{static_prefix})(/.*|$)}
+          prefix = $1
+          paths = $2.gsub(%r{^/|/$}, '').split('/')
+          library, paths = *parse_library_from_path(paths)
+          return unless library
+          return case prefix
+                 when docs_prefix;   route_docs(library, paths)
+                 when list_prefix;   route_list(library, paths)
+                 when search_prefix; route_search(library, paths)
+                 when static_prefix; route_static(library, paths)
+                 end
+        end
+        nil
+      end
+
+      # Routes requests from {#docs_prefix} and calls the appropriate command
+      # @param [LibraryVersion] library the library to route for
+      # @param [Array<String>] paths path components (split by '/')
+      # @return (see #route)
+      def route_docs(library, paths)
+        return route_index if library.nil?
+        case paths.first
+        when "frames"
+          paths.shift
+          cmd = DisplayObjectCommand
+        when "file"
+          paths.shift
+          cmd = DisplayFileCommand
+        else
+          cmd = DisplayObjectCommand
+        end
+        cmd = cmd.new(final_options(library, paths))
+        cmd.call(request)
+      end
+
+      # Routes for the index of a library / multiple libraries
+      # @return (see #route)
+      def route_index
+        if adapter.options[:single_library]
+          route_docs(adapter.libraries.values.first.first, [])
+        else
+          LibraryIndexCommand.new(adapter.options.merge(:path => '')).call(request)
+        end
+      end
+
+      # Routes requests from {#list_prefix} and calls the appropriate command
+      # @param (see #route_docs)
+      # @return (see #route_docs)
+      def route_list(library, paths)
+        return if paths.empty?
+        ListCommand.new(final_options(library, paths)).call(request)
+      end
+
+      # Routes requests from {#search_prefix} and calls the appropriate command
+      # @param (see #route_docs)
+      # @return (see #route_docs)
+      def route_search(library, paths)
+        return unless paths.empty?
+        SearchCommand.new(final_options(library, paths)).call(request)
+      end
+
+      def route_static(library, paths)
+        StaticFileCommand.new(final_options(library, paths)).call(request)
+      end
+
+      # @group Utility Methods
+
+      # Adds extra :library/:path option keys to the adapter options.
+      # Use this method when passing options to a command.
+      #
+      # @param (see #route_docs)
+      # @return [Hash] finalized options
+      def final_options(library, paths)
+        path = File.cleanpath(paths.join('/')).gsub(%r{^(\.\./)+}, '')
+        adapter.options.merge(:library => library, :path => path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'fileutils'
+
+module YARD
+  module Server
+    # Implements static caching for requests.
+    #
+    # @see Router Router documentation for "Caching"
+    module StaticCaching
+      # Called by a router to return the cached object. By default, this
+      # method performs disk-based caching. To perform other forms of caching,
+      # implement your own +#check_static_cache+ method and mix the module into
+      # the Router class.
+      #
+      # This method checks for the existence of cached data. To actually cache
+      # a response, see {#cache}.
+      #
+      # @example Implementing In-Memory Cache Checking
+      #   module MemoryCaching
+      #     def check_static_cache
+      #       # $memory_cache is filled by {Commands::Base#cache}
+      #       cached_data = $memory_cache[request.path]
+      #       if cached_data
+      #         [200, {'Content-Type' => 'text/html'}, [cached_data]]
+      #       else
+      #         nil
+      #       end
+      #     end
+      #   end
+      #
+      #   class YARD::Server::Router; include MemoryCaching; end
+      # @return [Array(Numeric,Hash,Array)] the Rack-style response
+      # @return [nil] if no cache is available and routing should continue
+      # @see Commands::Base#cache
+      def check_static_cache
+        return nil unless adapter.document_root
+        cache_path = cache_path(request.path)
+        return nil unless cache_path
+
+        if File.file?(cache_path)
+          log.debug "Loading cache from disk: #{cache_path}"
+          return [200, {'Content-Type' => 'text/html'}, [File.read_binary(cache_path)]]
+        end
+        nil
+      end
+
+      # Caches rendered HTML response data to disk.
+      #
+      # @param [String] data the data to cache
+      # @return [void]
+      # @since 0.9.44
+      def cache(data)
+        return unless adapter.document_root
+
+        path = cache_path(request.path_info)
+        return unless path
+
+        FileUtils.mkdir_p(File.dirname(path))
+        log.debug "Caching data to #{path}"
+        File.open(path, 'wb') {|f| f.write(data) }
+      end
+
+      private
+
+      def cache_path(request_path)
+        return nil if request_path.split(/[\/\\]/).include?('..')
+
+        path = request_path.sub(/\.html$/, '') + '.html'
+        path = path.sub(%r{\A/+}, '')
+        return nil if path =~ /\A[A-Za-z]:/
+
+        path = File.cleanpath(path)
+        File.join(adapter.document_root, path)
+      end
+    end
+  end
+end