yard 0.9.18 → 0.9.19

data/lib/yard/cli/help.rb

@@ -1,20 +1,20 @@
-# frozen_string_literal: true
-module YARD
-  module CLI
-    # Handles help for commands
-    # @since 0.6.0
-    class Help < Command
-      def description; "Retrieves help for a command" end
-
-      def run(*args)
-        cmd = args.first && CommandParser.commands[args.first.to_sym]
-        if cmd
-          cmd.run('--help')
-        else
-          log.puts "Command #{args.first} not found." if args.first
-          CommandParser.run('--help')
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module CLI
+    # Handles help for commands
+    # @since 0.6.0
+    class Help < Command
+      def description; "Retrieves help for a command" end
+
+      def run(*args)
+        cmd = args.first && CommandParser.commands[args.first.to_sym]
+        if cmd
+          cmd.run('--help')
+        else
+          log.puts "Command #{args.first} not found." if args.first
+          CommandParser.run('--help')
+        end
+      end
+    end
+  end
+end

data/lib/yard/cli/i18n.rb

@@ -1,70 +1,70 @@
-# frozen_string_literal: true
-require "pathname"
-
-module YARD
-  module CLI
-    # CLI command to support internationalization (a.k.a. i18n).
-    # I18n feature is based on gettext technology.
-    # This command generates .pot file from docstring and extra
-    # documentation.
-    #
-    # @since 0.8.0
-    # @todo Support msgminit and msgmerge features?
-    class I18n < Yardoc
-      def initialize
-        super
-        @options.serializer.basepath = "po/yard.pot"
-      end
-
-      def description
-        'Generates .pot file from source code and extra documentation'
-      end
-
-      def run(*args)
-        if args.empty? || !args.first.nil?
-          # fail early if arguments are not valid
-          return unless parse_arguments(*args)
-        end
-
-        YARD.parse(files, excluded)
-
-        serializer = options.serializer
-        pot_file_path = Pathname.new(serializer.basepath).expand_path
-        pot_file_dir_path, pot_file_basename = pot_file_path.split
-        relative_base_path = Pathname.pwd.relative_path_from(pot_file_dir_path)
-        serializer.basepath = pot_file_dir_path.to_s
-        serializer.serialize(pot_file_basename.to_s,
-                             generate_pot(relative_base_path.to_s))
-
-        true
-      end
-
-      private
-
-      def general_options(opts)
-        opts.banner = "Usage: yard i18n [options] [source_files [- extra_files]]"
-        opts.top.list.clear
-        opts.separator "(if a list of source files is omitted, "
-        opts.separator "  {lib,app}/**/*.rb ext/**/*.{c,rb} is used.)"
-        opts.separator ""
-        opts.separator "Example: yard i18n -o yard.pot - FAQ LICENSE"
-        opts.separator "  The above example outputs .pot file for files in"
-        opts.separator "  lib/**/*.rb to yard.pot including the extra files"
-        opts.separator "  FAQ and LICENSE."
-        opts.separator ""
-        opts.separator "A base set of options can be specified by adding a .yardopts"
-        opts.separator "file to your base path containing all extra options separated"
-        opts.separator "by whitespace."
-        super(opts)
-      end
-
-      def generate_pot(relative_base_path)
-        generator = YARD::I18n::PotGenerator.new(relative_base_path)
-        objects = run_verifier(all_objects)
-        generator.parse_objects(objects)
-        generator.parse_files(options.files || [])
-        generator.generate
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+require "pathname"
+
+module YARD
+  module CLI
+    # CLI command to support internationalization (a.k.a. i18n).
+    # I18n feature is based on gettext technology.
+    # This command generates .pot file from docstring and extra
+    # documentation.
+    #
+    # @since 0.8.0
+    # @todo Support msgminit and msgmerge features?
+    class I18n < Yardoc
+      def initialize
+        super
+        @options.serializer.basepath = "po/yard.pot"
+      end
+
+      def description
+        'Generates .pot file from source code and extra documentation'
+      end
+
+      def run(*args)
+        if args.empty? || !args.first.nil?
+          # fail early if arguments are not valid
+          return unless parse_arguments(*args)
+        end
+
+        YARD.parse(files, excluded)
+
+        serializer = options.serializer
+        pot_file_path = Pathname.new(serializer.basepath).expand_path
+        pot_file_dir_path, pot_file_basename = pot_file_path.split
+        relative_base_path = Pathname.pwd.relative_path_from(pot_file_dir_path)
+        serializer.basepath = pot_file_dir_path.to_s
+        serializer.serialize(pot_file_basename.to_s,
+                             generate_pot(relative_base_path.to_s))
+
+        true
+      end
+
+      private
+
+      def general_options(opts)
+        opts.banner = "Usage: yard i18n [options] [source_files [- extra_files]]"
+        opts.top.list.clear
+        opts.separator "(if a list of source files is omitted, "
+        opts.separator "  {lib,app}/**/*.rb ext/**/*.{c,rb} is used.)"
+        opts.separator ""
+        opts.separator "Example: yard i18n -o yard.pot - FAQ LICENSE"
+        opts.separator "  The above example outputs .pot file for files in"
+        opts.separator "  lib/**/*.rb to yard.pot including the extra files"
+        opts.separator "  FAQ and LICENSE."
+        opts.separator ""
+        opts.separator "A base set of options can be specified by adding a .yardopts"
+        opts.separator "file to your base path containing all extra options separated"
+        opts.separator "by whitespace."
+        super(opts)
+      end
+
+      def generate_pot(relative_base_path)
+        generator = YARD::I18n::PotGenerator.new(relative_base_path)
+        objects = run_verifier(all_objects)
+        generator.parse_objects(objects)
+        generator.parse_files(options.files || [])
+        generator.generate
+      end
+    end
+  end
+end

data/lib/yard/cli/list.rb

@@ -1,23 +1,23 @@
-# frozen_string_literal: true
-module YARD
-  module CLI
-    # Lists all constant and method names in the codebase. Uses {Yardoc} --list.
-    class List < Command
-      def description; 'Lists all constant and methods. Uses `yard doc --list`' end
-
-      # Runs the commandline utility, parsing arguments and displaying a
-      # list of objects
-      #
-      # @param [Array<String>] args the list of arguments.
-      # @return [void]
-      def run(*args)
-        if args.include?('--help')
-          log.puts "Usage: yard list [yardoc_options]"
-          log.puts "Takes the same arguments as yardoc. See yardoc --help"
-        else
-          Yardoc.run('-c', '--list', *args)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module CLI
+    # Lists all constant and method names in the codebase. Uses {Yardoc} --list.
+    class List < Command
+      def description; 'Lists all constant and methods. Uses `yard doc --list`' end
+
+      # Runs the commandline utility, parsing arguments and displaying a
+      # list of objects
+      #
+      # @param [Array<String>] args the list of arguments.
+      # @return [void]
+      def run(*args)
+        if args.include?('--help')
+          log.puts "Usage: yard list [yardoc_options]"
+          log.puts "Takes the same arguments as yardoc. See yardoc --help"
+        else
+          Yardoc.run('-c', '--list', *args)
+        end
+      end
+    end
+  end
+end

data/lib/yard/cli/markup_types.rb

@@ -1,32 +1,32 @@
-# frozen_string_literal: true
-module YARD
-  module CLI
-    # Lists all markup types
-    # @since 0.8.6
-    class MarkupTypes < Command
-      def description; 'Lists all available markup types and libraries' end
-
-      # Runs the commandline utility, parsing arguments and displaying a
-      # list of markup types
-      #
-      # @param [Array<String>] args the list of arguments.
-      # @return [void]
-      def run(*args) # rubocop:disable Lint/UnusedMethodArgument
-        log.puts "Available markup types for `doc' command:"
-        log.puts
-        types = Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS
-        exts = Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS
-        types.sort_by {|name, _| name.to_s }.each do |name, providers|
-          log.puts "[#{name}]"
-          libs = providers.map {|p| p[:lib] }.compact
-          log.puts "  Providers: #{libs.join(" ")}" unless libs.empty?
-          if exts[name]
-            log.puts "  Extensions: #{exts[name].map {|e| ".#{e}" }.join(" ")}"
-          end
-
-          log.puts
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module CLI
+    # Lists all markup types
+    # @since 0.8.6
+    class MarkupTypes < Command
+      def description; 'Lists all available markup types and libraries' end
+
+      # Runs the commandline utility, parsing arguments and displaying a
+      # list of markup types
+      #
+      # @param [Array<String>] args the list of arguments.
+      # @return [void]
+      def run(*args) # rubocop:disable Lint/UnusedMethodArgument
+        log.puts "Available markup types for `doc' command:"
+        log.puts
+        types = Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS
+        exts = Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS
+        types.sort_by {|name, _| name.to_s }.each do |name, providers|
+          log.puts "[#{name}]"
+          libs = providers.map {|p| p[:lib] }.compact
+          log.puts "  Providers: #{libs.join(" ")}" unless libs.empty?
+          if exts[name]
+            log.puts "  Extensions: #{exts[name].map {|e| ".#{e}" }.join(" ")}"
+          end
+
+          log.puts
+        end
+      end
+    end
+  end
+end

data/lib/yard/cli/server.rb

@@ -1,257 +1,257 @@
-# frozen_string_literal: true
-module YARD
-  module CLI
-    # A local documentation server
-    # @since 0.6.0
-    class Server < Command
-      # @return [Hash] a list of options to pass to the doc server
-      attr_accessor :options
-
-      # @return [Hash] a list of options to pass to the web server
-      attr_accessor :server_options
-
-      # @return [Hash] a list of library names and yardoc files to serve
-      attr_accessor :libraries
-
-      # @return [YARD::Server::Adapter] the adapter to use for loading the web server
-      attr_accessor :adapter
-
-      # @return [Array<String>] a list of scripts to load
-      # @since 0.6.2
-      attr_accessor :scripts
-
-      # @return [Array<String>] a list of template paths to register
-      # @since 0.6.2
-      attr_accessor :template_paths
-
-      # Creates a new instance of the Server command line utility
-      def initialize
-        super
-        self.scripts = []
-        self.template_paths = []
-        self.libraries = {}
-        self.options = SymbolHash.new(false).update(
-          :single_library => true,
-          :caching => false
-        )
-        self.server_options = {:Port => 8808}
-      end
-
-      def description
-        "Runs a local documentation server"
-      end
-
-      def run(*args)
-        optparse(*args)
-
-        select_adapter.setup
-        load_scripts
-        load_template_paths
-        adapter.new(libraries, options, server_options).start
-      end
-
-      private
-
-      def load_scripts
-        scripts.each {|file| load_script(file) }
-      end
-
-      def load_template_paths
-        return if YARD::Config.options[:safe_mode]
-        Templates::Engine.template_paths |= template_paths
-      end
-
-      def select_adapter
-        return adapter if adapter
-        require 'rubygems'
-        require 'rack'
-        self.adapter = YARD::Server::RackAdapter
-      rescue LoadError
-        self.adapter = YARD::Server::WebrickAdapter
-      end
-
-      def add_libraries(args)
-        (0...args.size).step(2) do |index|
-          library = args[index]
-          dir = args[index + 1]
-
-          libver = nil
-          if dir
-            if File.exist?(dir)
-              # Provided dir contains a .yardopts file
-              libver = create_library_version_if_yardopts_exist(library, dir)
-              libver ||= YARD::Server::LibraryVersion.new(library, nil, dir)
-            end
-          else
-            # Check if this dir contains a .yardopts file
-            pwd = Dir.pwd
-            libver = create_library_version_if_yardopts_exist(library, pwd)
-
-            # Check default location
-            yfile = File.join(pwd, Registry::DEFAULT_YARDOC_FILE)
-            libver ||= YARD::Server::LibraryVersion.new(library, nil, yfile)
-          end
-
-          # Register library
-          if libver
-            libver.yardoc_file = File.expand_path(libver.yardoc_file) if libver.yardoc_file
-            libver.source_path = File.expand_path(libver.source_path) if libver.source_path
-            libraries[library] ||= []
-            libraries[library] |= [libver]
-          else
-            log.warn "Cannot find yardoc db for #{library}: #{dir.inspect}"
-          end
-        end
-      end
-
-      # @param [String] library The library name.
-      # @param [String, nil] dir The argument provided on the CLI after the
-      #   library name. Is supposed to point to either a project directory
-      #   with a Yard options file, or a yardoc db.
-      # @return [LibraryVersion, nil]
-      def create_library_version_if_yardopts_exist(library, dir)
-        if dir
-          options_file = File.join(dir, Yardoc::DEFAULT_YARDOPTS_FILE)
-          if File.exist?(options_file)
-            # Found yardopts, extract db path
-            yfile = extract_db_from_options_file(options_file)
-            db = File.expand_path(yfile, dir)
-
-            # Create libver
-            libver = YARD::Server::LibraryVersion.new(library, nil, db)
-            libver.source_path = dir
-            libver
-          end
-        end
-      end
-
-      def add_gems
-        require 'rubygems'
-        YARD::GemIndex.each do |spec|
-          libraries[spec.name] ||= []
-          libraries[spec.name] |= [YARD::Server::LibraryVersion.new(spec.name, spec.version.to_s, nil, :gem)]
-        end
-      end
-
-      def add_gems_from_gemfile(gemfile = nil)
-        require 'bundler'
-        gemfile ||= "Gemfile"
-        if File.exist?("#{gemfile}.lock")
-          Bundler::LockfileParser.new(File.read("#{gemfile}.lock")).specs.each do |spec|
-            libraries[spec.name] ||= []
-            libraries[spec.name] |= [YARD::Server::LibraryVersion.new(spec.name, spec.version.to_s, nil, :gem)]
-          end
-        else
-          log.warn "Cannot find #{gemfile}.lock, ignoring --gemfile option"
-        end
-      rescue LoadError
-        log.error "Bundler not available, ignoring --gemfile option"
-      end
-
-      def optparse(*args)
-        opts = OptionParser.new
-        opts.banner = 'Usage: yard server [options] [[library yardoc_file] ...]'
-        opts.separator ''
-        opts.separator 'Example: yard server -m yard .yardoc ruby-core ../ruby/.yardoc'
-        opts.separator 'The above example serves documentation for YARD and Ruby-core'
-        opts.separator ''
-        opts.separator 'If no library/yardoc_file is specified, the server uses'
-        opts.separator 'the name of the current directory and `.yardoc` respectively'
-        opts.separator ''
-        opts.separator "General Options:"
-        opts.on('-m', '--multi-library', 'Serves documentation for multiple libraries') do
-          options[:single_library] = false
-        end
-        opts.on('-c', '--cache', 'Caches all documentation to document root (see --docroot)') do
-          options[:caching] = true
-        end
-        opts.on('-r', '--reload', 'Reparses the library code on each request') do
-          options[:incremental] = true
-        end
-        opts.on('-g', '--gems', 'Serves documentation for installed gems') do
-          add_gems
-        end
-        opts.on('-G', '--gemfile [GEMFILE]', 'Serves documentation for gems from Gemfile') do |gemfile|
-          add_gems_from_gemfile(gemfile)
-        end
-        opts.on('-t', '--template-path PATH',
-                'The template path to look for templates in. (used with -t).') do |path|
-          template_paths << path
-        end
-        opts.separator ''
-        opts.separator "Web Server Options:"
-        opts.on('-d', '--daemon', 'Daemonizes the server process') do
-          server_options[:daemonize] = true
-        end
-        opts.on('-B HOST', '--bind', 'The host address to bind to') do |host|
-          server_options[:Host] = host.to_s
-        end
-        opts.on('-p PORT', '--port', 'Serves documentation on PORT') do |port|
-          server_options[:Port] = port.to_i
-        end
-        opts.on('--docroot DOCROOT', 'Uses DOCROOT as document root') do |docroot|
-          server_options[:DocumentRoot] = File.expand_path(docroot)
-        end
-        opts.on('-a', '--adapter ADAPTER', 'Use the ADAPTER (full Ruby class) for web server') do |adapter|
-          if adapter.casecmp('webrick') == 0
-            self.adapter = YARD::Server::WebrickAdapter
-          elsif adapter.casecmp('rack') == 0
-            self.adapter = YARD::Server::RackAdapter
-          else
-            self.adapter = eval(adapter) # rubocop:disable Lint/Eval
-          end
-        end
-        opts.on('-s', '--server TYPE', 'Use a specific server type eg. thin,mongrel,cgi (Rack specific)') do |type|
-          server_options[:server] = type
-        end
-        opts.on('--fork', 'Use process forking when serving requests') do
-          options[:use_fork] = true
-        end
-        common_options(opts)
-        opts.on('-e', '--load FILE', 'A Ruby script to load before the source tree is parsed.') do |file|
-          scripts << file
-        end
-        parse_options(opts, args)
-
-        if args.empty? && libraries.empty?
-          # No args - try to use current dir
-          add_libraries([File.basename(Dir.pwd), nil])
-
-          # Generate doc for first time
-          # This is not necessary but makes for a better first-run experience
-          libver = libraries.empty? ? nil : libraries.values.first.first
-          generate_doc_for_first_time(libver) if libver && !libver.ready?
-        else
-          add_libraries(args)
-          options[:single_library] = false if libraries.size > 1
-        end
-      end
-
-      def generate_doc_for_first_time(libver)
-        log.enter_level(Logger::INFO) do
-          yardoc_file = libver.yardoc_file.sub(%r{^#{Regexp.quote Dir.pwd}[\\/]+}, '')
-          log.info "No yardoc db found in #{yardoc_file}, parsing source before starting server..."
-        end
-        Dir.chdir(libver.source_path) do
-          Yardoc.run('-n')
-        end
-      end
-
-      def extract_db_from_options_file(options_file)
-        args = File.read_binary(options_file).shell_split
-        db = YARD::Registry.yardoc_file
-        opts = OptionParser.new
-        opts.on('-b', '--db FILE') {|file| db = file }
-
-        begin
-          opts.parse!(args)
-        rescue OptionParser::ParseError
-          args.shift if args.first && args.first[0, 1] != '-'
-          retry
-        end
-
-        db
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module CLI
+    # A local documentation server
+    # @since 0.6.0
+    class Server < Command
+      # @return [Hash] a list of options to pass to the doc server
+      attr_accessor :options
+
+      # @return [Hash] a list of options to pass to the web server
+      attr_accessor :server_options
+
+      # @return [Hash] a list of library names and yardoc files to serve
+      attr_accessor :libraries
+
+      # @return [YARD::Server::Adapter] the adapter to use for loading the web server
+      attr_accessor :adapter
+
+      # @return [Array<String>] a list of scripts to load
+      # @since 0.6.2
+      attr_accessor :scripts
+
+      # @return [Array<String>] a list of template paths to register
+      # @since 0.6.2
+      attr_accessor :template_paths
+
+      # Creates a new instance of the Server command line utility
+      def initialize
+        super
+        self.scripts = []
+        self.template_paths = []
+        self.libraries = {}
+        self.options = SymbolHash.new(false).update(
+          :single_library => true,
+          :caching => false
+        )
+        self.server_options = {:Port => 8808}
+      end
+
+      def description
+        "Runs a local documentation server"
+      end
+
+      def run(*args)
+        optparse(*args)
+
+        select_adapter.setup
+        load_scripts
+        load_template_paths
+        adapter.new(libraries, options, server_options).start
+      end
+
+      private
+
+      def load_scripts
+        scripts.each {|file| load_script(file) }
+      end
+
+      def load_template_paths
+        return if YARD::Config.options[:safe_mode]
+        Templates::Engine.template_paths |= template_paths
+      end
+
+      def select_adapter
+        return adapter if adapter
+        require 'rubygems'
+        require 'rack'
+        self.adapter = YARD::Server::RackAdapter
+      rescue LoadError
+        self.adapter = YARD::Server::WebrickAdapter
+      end
+
+      def add_libraries(args)
+        (0...args.size).step(2) do |index|
+          library = args[index]
+          dir = args[index + 1]
+
+          libver = nil
+          if dir
+            if File.exist?(dir)
+              # Provided dir contains a .yardopts file
+              libver = create_library_version_if_yardopts_exist(library, dir)
+              libver ||= YARD::Server::LibraryVersion.new(library, nil, dir)
+            end
+          else
+            # Check if this dir contains a .yardopts file
+            pwd = Dir.pwd
+            libver = create_library_version_if_yardopts_exist(library, pwd)
+
+            # Check default location
+            yfile = File.join(pwd, Registry::DEFAULT_YARDOC_FILE)
+            libver ||= YARD::Server::LibraryVersion.new(library, nil, yfile)
+          end
+
+          # Register library
+          if libver
+            libver.yardoc_file = File.expand_path(libver.yardoc_file) if libver.yardoc_file
+            libver.source_path = File.expand_path(libver.source_path) if libver.source_path
+            libraries[library] ||= []
+            libraries[library] |= [libver]
+          else
+            log.warn "Cannot find yardoc db for #{library}: #{dir.inspect}"
+          end
+        end
+      end
+
+      # @param [String] library The library name.
+      # @param [String, nil] dir The argument provided on the CLI after the
+      #   library name. Is supposed to point to either a project directory
+      #   with a Yard options file, or a yardoc db.
+      # @return [LibraryVersion, nil]
+      def create_library_version_if_yardopts_exist(library, dir)
+        if dir
+          options_file = File.join(dir, Yardoc::DEFAULT_YARDOPTS_FILE)
+          if File.exist?(options_file)
+            # Found yardopts, extract db path
+            yfile = extract_db_from_options_file(options_file)
+            db = File.expand_path(yfile, dir)
+
+            # Create libver
+            libver = YARD::Server::LibraryVersion.new(library, nil, db)
+            libver.source_path = dir
+            libver
+          end
+        end
+      end
+
+      def add_gems
+        require 'rubygems'
+        YARD::GemIndex.each do |spec|
+          libraries[spec.name] ||= []
+          libraries[spec.name] |= [YARD::Server::LibraryVersion.new(spec.name, spec.version.to_s, nil, :gem)]
+        end
+      end
+
+      def add_gems_from_gemfile(gemfile = nil)
+        require 'bundler'
+        gemfile ||= "Gemfile"
+        if File.exist?("#{gemfile}.lock")
+          Bundler::LockfileParser.new(File.read("#{gemfile}.lock")).specs.each do |spec|
+            libraries[spec.name] ||= []
+            libraries[spec.name] |= [YARD::Server::LibraryVersion.new(spec.name, spec.version.to_s, nil, :gem)]
+          end
+        else
+          log.warn "Cannot find #{gemfile}.lock, ignoring --gemfile option"
+        end
+      rescue LoadError
+        log.error "Bundler not available, ignoring --gemfile option"
+      end
+
+      def optparse(*args)
+        opts = OptionParser.new
+        opts.banner = 'Usage: yard server [options] [[library yardoc_file] ...]'
+        opts.separator ''
+        opts.separator 'Example: yard server -m yard .yardoc ruby-core ../ruby/.yardoc'
+        opts.separator 'The above example serves documentation for YARD and Ruby-core'
+        opts.separator ''
+        opts.separator 'If no library/yardoc_file is specified, the server uses'
+        opts.separator 'the name of the current directory and `.yardoc` respectively'
+        opts.separator ''
+        opts.separator "General Options:"
+        opts.on('-m', '--multi-library', 'Serves documentation for multiple libraries') do
+          options[:single_library] = false
+        end
+        opts.on('-c', '--cache', 'Caches all documentation to document root (see --docroot)') do
+          options[:caching] = true
+        end
+        opts.on('-r', '--reload', 'Reparses the library code on each request') do
+          options[:incremental] = true
+        end
+        opts.on('-g', '--gems', 'Serves documentation for installed gems') do
+          add_gems
+        end
+        opts.on('-G', '--gemfile [GEMFILE]', 'Serves documentation for gems from Gemfile') do |gemfile|
+          add_gems_from_gemfile(gemfile)
+        end
+        opts.on('-t', '--template-path PATH',
+                'The template path to look for templates in. (used with -t).') do |path|
+          template_paths << path
+        end
+        opts.separator ''
+        opts.separator "Web Server Options:"
+        opts.on('-d', '--daemon', 'Daemonizes the server process') do
+          server_options[:daemonize] = true
+        end
+        opts.on('-B HOST', '--bind', 'The host address to bind to') do |host|
+          server_options[:Host] = host.to_s
+        end
+        opts.on('-p PORT', '--port', 'Serves documentation on PORT') do |port|
+          server_options[:Port] = port.to_i
+        end
+        opts.on('--docroot DOCROOT', 'Uses DOCROOT as document root') do |docroot|
+          server_options[:DocumentRoot] = File.expand_path(docroot)
+        end
+        opts.on('-a', '--adapter ADAPTER', 'Use the ADAPTER (full Ruby class) for web server') do |adapter|
+          if adapter.casecmp('webrick') == 0
+            self.adapter = YARD::Server::WebrickAdapter
+          elsif adapter.casecmp('rack') == 0
+            self.adapter = YARD::Server::RackAdapter
+          else
+            self.adapter = eval(adapter) # rubocop:disable Lint/Eval
+          end
+        end
+        opts.on('-s', '--server TYPE', 'Use a specific server type eg. thin,mongrel,cgi (Rack specific)') do |type|
+          server_options[:server] = type
+        end
+        opts.on('--fork', 'Use process forking when serving requests') do
+          options[:use_fork] = true
+        end
+        common_options(opts)
+        opts.on('-e', '--load FILE', 'A Ruby script to load before the source tree is parsed.') do |file|
+          scripts << file
+        end
+        parse_options(opts, args)
+
+        if args.empty? && libraries.empty?
+          # No args - try to use current dir
+          add_libraries([File.basename(Dir.pwd), nil])
+
+          # Generate doc for first time
+          # This is not necessary but makes for a better first-run experience
+          libver = libraries.empty? ? nil : libraries.values.first.first
+          generate_doc_for_first_time(libver) if libver && !libver.ready?
+        else
+          add_libraries(args)
+          options[:single_library] = false if libraries.size > 1
+        end
+      end
+
+      def generate_doc_for_first_time(libver)
+        log.enter_level(Logger::INFO) do
+          yardoc_file = libver.yardoc_file.sub(%r{^#{Regexp.quote Dir.pwd}[\\/]+}, '')
+          log.info "No yardoc db found in #{yardoc_file}, parsing source before starting server..."
+        end
+        Dir.chdir(libver.source_path) do
+          Yardoc.run('-n')
+        end
+      end
+
+      def extract_db_from_options_file(options_file)
+        args = File.read_binary(options_file).shell_split
+        db = YARD::Registry.yardoc_file
+        opts = OptionParser.new
+        opts.on('-b', '--db FILE') {|file| db = file }
+
+        begin
+          opts.parse!(args)
+        rescue OptionParser::ParseError
+          args.shift if args.first && args.first[0, 1] != '-'
+          retry
+        end
+
+        db
+      end
+    end
+  end
+end