hyper-pro-gem 0.0.1

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # This is the base command class used to implement custom commands for
+      # a server. A command will be routed to by the {Router} class and return
+      # a Rack-style response.
+      #
+      # == Attribute Initializers
+      # All attributes can be initialized via options passed into the {#initialize}
+      # method. When creating a custom command, the {Adapter#options} will
+      # automatically be mapped to attributes by the same name on your class.
+      #
+      #   class MyCommand < Base
+      #     attr_accessor :myattr
+      #   end
+      #
+      #   Adapter.new(libs, {:myattr => 'foo'}).start
+      #
+      #   # when a request comes in, cmd.myattr == 'foo'
+      #
+      # == Subclassing Notes
+      # To implement a custom command, override the {#run} method, not {#call}.
+      # In your implementation, you should set the body and status for requests.
+      # See details in the +#run+ method documentation.
+      #
+      # Note that if your command deals directly with libraries, you should
+      # consider subclassing the more specific {LibraryCommand} class instead.
+      #
+      # @abstract
+      # @see #run
+      class Base
+        include StaticCaching
+
+        # @group Basic Command and Adapter Options
+
+        # @return [Hash] the options passed to the command's constructor
+        attr_accessor :command_options
+
+        # @return [Adapter] the server adapter
+        attr_accessor :adapter
+
+        # @return [Boolean] whether to cache
+        attr_accessor :caching
+
+        # @group Attributes Set Per Request
+
+        # @return [Rack::Request] request object
+        attr_accessor :request
+
+        # @return [String] the path after the command base URI
+        attr_accessor :path
+
+        # @return [Hash{String => String}] response headers
+        attr_accessor :headers
+
+        # @return [Numeric] status code. Defaults to 200 per request
+        attr_accessor :status
+
+        # @return [String] the response body. Defaults to empty string.
+        attr_accessor :body
+
+        # @group Instance Method Summary
+
+        # Creates a new command object, setting attributes named by keys
+        # in the options hash. After initialization, the options hash
+        # is saved in {#command_options} for further inspection.
+        #
+        # @example Creating a Command
+        #   cmd = DisplayObjectCommand.new(:caching => true, :library => mylib)
+        #   cmd.library # => mylib
+        #   cmd.command_options # => {:caching => true, :library => mylib}
+        # @param [Hash] opts the options hash, saved to {#command_options}
+        #   after initialization.
+        def initialize(opts = {})
+          opts.each do |key, value|
+            send("#{key}=", value) if respond_to?("#{key}=")
+          end
+          self.command_options = opts
+        end
+
+        # The main method called by a router with a request object.
+        #
+        # @note This command should not be overridden by subclasses. Implement
+        #   the callback method {#run} instead.
+        # @param [Adapter Dependent] request the request object
+        # @return [Array(Numeric,Hash,Array<String>)] a Rack-style response
+        #   of status, headers, and body wrapped in an array.
+        def call(request)
+          self.request = request
+          self.path ||= File.cleanpath(request.path_info[1..-1])
+          self.headers = {'Content-Type' => 'text/html'}
+          self.body = ''
+          self.status = 200
+          add_cache_control
+          begin
+            run
+          rescue FinishRequest
+            nil # noop
+          rescue NotFoundError => e
+            self.body = e.message if e.message != e.class.to_s
+            not_found
+          end
+
+          # keep this to support commands setting status manually.
+          not_found if status == 404
+
+          [status, headers, body.is_a?(Array) ? body : [body]]
+        end
+
+        # @group Abstract Methods
+
+        # Subclass this method to implement a custom command. This method
+        # should set the {#status} and {#body}, and optionally modify the
+        # {#headers}. Note that +#status+ defaults to 200.
+        #
+        # @example A custom command
+        #   class ErrorCommand < Base
+        #     def run
+        #       self.body = 'ERROR! The System is down!'
+        #       self.status = 500
+        #       self.headers['Content-Type'] = 'text/plain'
+        #     end
+        #   end
+        #
+        # @abstract
+        # @return [void]
+        def run
+          raise NotImplementedError
+        end
+
+        protected
+
+        # @group Helper Methods
+
+        # Renders a specific object if provided, or a regular template rendering
+        # if object is not provided.
+        #
+        # @todo This method is dependent on +#options+, it should be in {LibraryCommand}.
+        # @param [CodeObjects::Base, nil] object calls {CodeObjects::Base#format} if
+        #   an object is provided, or {Templates::Engine.render} if object is nil. Both
+        #   receive +#options+ as an argument.
+        # @return [String] the resulting output to display
+        def render(object = nil)
+          case object
+          when CodeObjects::Base
+            cache object.format(options)
+          when nil
+            cache Templates::Engine.render(options)
+          else
+            cache object
+          end
+        end
+
+        # Override this method to implement custom caching mechanisms for
+        #
+        # @example Caching to memory
+        #   $memory_cache = {}
+        #   def cache(data)
+        #     $memory_cache[path] = data
+        #   end
+        # @param [String] data the data to cache
+        # @return [String] the same cached data (for chaining)
+        # @see StaticCaching
+        def cache(data)
+          super if caching
+          self.body = data
+        end
+
+        # Sets the body and headers for a 404 response. Does not modify the
+        # body if already set.
+        #
+        # @return [void]
+        def not_found
+          self.status = 404
+          return unless body.empty?
+          self.body = "Not found: #{request.path}"
+          headers['Content-Type'] = 'text/plain'
+          headers['X-Cascade'] = 'pass'
+          headers['Cache-Control'] = 'nocache'
+        end
+
+        # Sets the headers and status code for a redirection to a given URL
+        # @param [String] url the URL to redirect to
+        # @raise [FinishRequest] causes the request to terminate.
+        def redirect(url)
+          headers['Location'] = url
+          self.status = 302
+          raise FinishRequest
+        end
+
+        private
+
+        # Add a conservative cache control policy to reduce load on
+        # requests served with "?1234567890" style timestamp query strings.
+        def add_cache_control
+          return if request.query_string.to_i == 0
+          headers['Cache-Control'] ||= 'public, max-age=300'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Displays a README or extra file.
+      #
+      # @todo Implement better support for detecting binary (image) filetypes
+      class DisplayFileCommand < LibraryCommand
+        attr_accessor :index
+
+        def run
+          filename = File.cleanpath(File.join(library.source_path, path))
+          raise NotFoundError unless File.file?(filename)
+          if filename =~ /\.(jpe?g|gif|png|bmp|svg)$/i
+            headers['Content-Type'] = StaticFileCommand::DefaultMimeTypes[$1.downcase] || 'text/html'
+            render File.read_binary(filename)
+          else
+            file = CodeObjects::ExtraFileObject.new(filename)
+            options.update :object => Registry.root,
+                           :type => :layout,
+                           :file => file,
+                           :index => index ? true : false
+            render
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Displays documentation for a specific object identified by the path
+      class DisplayObjectCommand < LibraryCommand
+        include DocServerHelper
+
+        def run
+          if path.empty?
+            if options.readme
+              filename = options.readme.filename
+              opts = adapter.options.merge(
+                :index => true, :library => library,
+                :path => filename.sub(%r{^#{library.source_path.to_s}/}, '')
+              )
+              self.status, self.headers, self.body =
+                *DisplayFileCommand.new(opts).call(request)
+              cache(body)
+              return
+            else
+              self.path = 'index'
+            end
+          end
+          return index if path == 'index'
+
+          object = Registry.at(object_path)
+          if object
+            options.update(:type => :layout)
+            render(object)
+          else
+            not_found
+          end
+        end
+
+        def index
+          Registry.load_all
+
+          options.update(
+            :object => '_index.html',
+            :objects => Registry.all(:module, :class),
+            :type => :layout
+          )
+          render
+        end
+
+        def not_found
+          super
+          self.body = "Could not find object: #{object_path}"
+        end
+
+        private
+
+        def object_path
+          return @object_path if @object_path
+          if path == "toplevel"
+            @object_path = :root
+          else
+            @object_path = path.sub(':', '#').gsub('/', '::').sub(/^toplevel\b/, '').sub(/\.html$/, '')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Displays an object wrapped in frames
+      class FramesCommand < DisplayObjectCommand
+        def run
+          options.update(:frames => true, :type => :fulldoc)
+          tpl = fulldoc_template
+          tpl.generate_frameset
+          cache(tpl.contents)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+require 'thread'
+
+module YARD
+  module Server
+    module Commands
+      class LibraryOptions < CLI::YardocOptions
+        def adapter; @command.adapter end
+        def library; @command.library end
+        def single_library; @command.single_library end
+        def serializer; @command.serializer end
+        def serialize; false end
+
+        attr_accessor :command
+        attr_accessor :frames
+
+        def each(&block)
+          super(&block)
+          yield(:adapter, adapter)
+          yield(:library, library)
+          yield(:single_library, single_library)
+          yield(:serializer, serializer)
+        end
+      end
+
+      # This is the base command for all commands that deal directly with libraries.
+      # Some commands do not, but most (like {DisplayObjectCommand}) do. If your
+      # command deals with libraries directly, subclass this class instead.
+      # See {Base} for notes on how to subclass a command.
+      #
+      # @abstract
+      class LibraryCommand < Base
+        begin
+          Process.fork { }
+          CAN_FORK = true
+        rescue Exception # rubocop:disable Lint/RescueException
+          CAN_FORK = false
+        end
+
+        # @return [LibraryVersion] the object containing library information
+        attr_accessor :library
+
+        # @return [LibraryOptions] default options for the library
+        attr_accessor :options
+
+        # @return [Serializers::Base] the serializer used to perform file linking
+        attr_accessor :serializer
+
+        # @return [Boolean] whether router should route for multiple libraries
+        attr_accessor :single_library
+
+        # @return [Boolean] whether to reparse data
+        attr_accessor :incremental
+
+        # @return [Boolean] whether or not this adapter calls +fork+ when serving
+        #   library requests. Defaults to false.
+        attr_accessor :use_fork
+
+        # Needed to synchronize threads in {#setup_yardopts}
+        # @private
+        @@library_chdir_lock = Mutex.new
+
+        def initialize(opts = {})
+          super
+          self.serializer = DocServerSerializer.new
+        end
+
+        def call(request)
+          if can_fork?
+            call_with_fork(request) { super }
+          else
+            begin
+              save_default_template_info
+              call_without_fork(request) { super }
+            ensure
+              restore_template_info
+            end
+          end
+        end
+
+        private
+
+        def call_without_fork(request)
+          self.request = request
+          self.options = LibraryOptions.new
+          options.reset_defaults
+          options.command = self
+          setup_library
+          options.title = "Documentation for #{library.name} " +
+                          (library.version ? '(' + library.version + ')' : '')
+          yield
+        rescue LibraryNotPreparedError
+          not_prepared
+        end
+
+        def call_with_fork(request, &block)
+          IO.pipe(:binmode => true) do |reader, writer|
+            fork do
+              log.debug "[pid=#{Process.pid}] fork serving: #{request.path}"
+              reader.close
+              writer.print(Marshal.dump(call_without_fork(request, &block)))
+            end
+
+            writer.close
+            Marshal.load(reader.read)
+          end
+        end
+
+        def can_fork?
+          CAN_FORK && use_fork
+        end
+
+        def save_default_template_info
+          @old_template_paths = Templates::Engine.template_paths.dup
+          @old_extra_includes = Templates::Template.extra_includes.dup
+        end
+
+        def restore_template_info
+          Templates::Engine.template_paths = @old_template_paths
+          Templates::Template.extra_includes = @old_extra_includes
+        end
+
+        def setup_library
+          library.prepare! if request.xhr? && request.query['process']
+          load_yardoc
+          setup_yardopts
+          true
+        end
+
+        def setup_yardopts
+          @@library_chdir_lock.synchronize do
+            Dir.chdir(library.source_path) do
+              yardoc = CLI::Yardoc.new
+              if incremental
+                yardoc.run('-c', '-n', '--no-stats')
+              else
+                yardoc.parse_arguments
+              end
+              yardoc.send(:verify_markup_options)
+              yardoc.options.delete(:serializer)
+              yardoc.options.delete(:serialize)
+              options.update(yardoc.options.to_hash)
+            end
+          end
+        end
+
+        def load_yardoc
+          raise LibraryNotPreparedError unless library.ready?
+          if Thread.current[:__yard_last_yardoc__] == library.yardoc_file
+            log.debug "Reusing yardoc file: #{library.yardoc_file}"
+            return
+          end
+          Registry.clear
+          Templates::ErbCache.clear!
+          Registry.load_yardoc(library.yardoc_file)
+          Thread.current[:__yard_last_yardoc__] = library.yardoc_file
+        end
+
+        def not_prepared
+          options.update(:template => :doc_server, :type => :processing)
+          self.caching = false
+          self.status = 202
+          self.body = render
+          self.headers = {'Content-Type' => 'text/html'}
+          [status, headers, [body]]
+        end
+
+        # Hack to load a custom fulldoc template object that does
+        # not do any rendering/generation. We need this to access the
+        # generate_*_list methods.
+        def fulldoc_template
+          tplopts = [options.template, :fulldoc, options.format]
+          tplclass = Templates::Engine.template(*tplopts)
+          obj = Object.new.extend(tplclass)
+          class << obj; define_method(:init) {} end
+          obj.class = tplclass
+          obj.send(:initialize, options)
+          class << obj
+            attr_reader :contents
+            define_method(:asset) {|_, contents| @contents = contents }
+          end
+          obj
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      class LibraryIndexOptions < CLI::YardocOptions
+        attr_accessor :adapter, :libraries
+        default_attr :template, :doc_server
+        default_attr :type, :library_list
+        default_attr :serialize, false
+      end
+
+      # Returns the index of libraries served by the server.
+      class LibraryIndexCommand < Base
+        attr_accessor :options
+
+        def run
+          return unless path.empty?
+
+          self.options = LibraryIndexOptions.new
+          options.adapter = adapter
+          options.libraries = adapter.libraries
+          options.reset_defaults
+          render
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Returns a list of objects of a specific type
+      class ListCommand < LibraryCommand
+        include Templates::Helpers::BaseHelper
+
+        def run
+          Registry.load_all
+          options.update(:objects => run_verifier(Registry.all(:class, :module)))
+          list_type = request.path.split('/').last
+          meth = "generate_#{list_type}_list"
+          tpl = fulldoc_template
+          if tpl.respond_to?(meth)
+            tpl.send(meth)
+            cache(tpl.contents)
+          else
+            not_found
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Serves requests from the root of the server
+      class RootRequestCommand < Base
+        include StaticFileHelpers
+
+        def run
+          static_template_file? || favicon? || not_found
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Performs a search over the objects inside of a library and returns
+      # the results as HTML or plaintext
+      class SearchCommand < LibraryCommand
+        include Templates::Helpers::BaseHelper
+        include Templates::Helpers::ModuleHelper
+        include DocServerHelper
+
+        attr_accessor :results, :query
+
+        def run
+          Registry.load_all
+          self.query = request.query['q']
+          redirect(abs_url(adapter.router.docs_prefix, single_library ? library : '')) if query.nil? || query =~ /\A\s*\Z/
+
+          found = Registry.at(query)
+          redirect(url_for(found)) if found
+
+          search_for_object
+          request.xhr? ? serve_xhr : serve_normal
+        end
+
+        def visible_results
+          results[0, 10]
+        end
+
+        private
+
+        def url_for(object)
+          abs_url(base_path(router.docs_prefix),
+            serializer.serialized_path(object))
+        end
+
+        def serve_xhr
+          headers['Content-Type'] = 'text/plain'
+          self.body = visible_results.map {|o|
+            [(o.type == :method ? o.name(true) : o.name).to_s,
+             o.path,
+             o.namespace.root? ? '' : o.namespace.path,
+             url_for(o)].join(",")
+          }.join("\n")
+        end
+
+        def serve_normal
+          options.update(
+            :visible_results => visible_results,
+            :query => query,
+            :results => results,
+            :template => :doc_server,
+            :type => :search
+          )
+          self.body = Templates::Engine.render(options)
+        end
+
+        def search_for_object
+          # rubocop:disable Style/MultilineBlockChain
+          self.results = run_verifier(Registry.all).select do |o|
+            o.path.downcase.include?(query.downcase)
+          end.reject do |o|
+            name = (o.type == :method ? o.name(true) : o.name).to_s.downcase
+            !name.include?(query.downcase) ||
+              case o.type
+              when :method
+                !(query =~ /[#.]/) && query.include?("::")
+              when :class, :module, :constant, :class_variable
+                query =~ /[#.]/
+              end
+          end.sort_by do |o|
+            name = (o.type == :method ? o.name(true) : o.name).to_s
+            name.length.to_f / query.length.to_f
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    module Commands
+      # Serves static content when no other router matches a request
+      class StaticFileCommand < LibraryCommand
+        include StaticFileHelpers
+
+        DefaultMimeTypes['js'] = 'text/javascript'
+
+        # Defines the paths used to search for static assets. To define an
+        # extra path, use {YARD::Server.register_static_path} rather than
+        # modifying this constant directly. Also note that files in the
+        # document root will always take precedence over these paths.
+        STATIC_PATHS = []
+
+        def run
+          static_template_file? || not_found
+        end
+      end
+    end
+  end
+end