yard 0.9.21 → 0.9.26

data/Rakefile

@@ -6,6 +6,8 @@ require 'samus'
 
 YARD::VERSION.replace(ENV['YARD_VERSION']) if ENV['YARD_VERSION']
 
+Dir['tasks/**/*.rake'].each { |task_file| load task_file }
+
 desc "Builds the gem"
 task :gem do
   sh "gem build yard.gemspec"

data/lib/yard/cli/diff.rb

@@ -161,7 +161,10 @@ module YARD
         url = "http://rubygems.org/downloads/#{gemfile}"
         log.info "Searching for remote gem file #{url}"
         begin
-          open(url) {|io| expand_and_parse(gemfile, io) }
+          # Note: In Ruby 2.4.x, URI.open is a private method. After
+          # 2.5, URI.open behaves much like Kernel#open once you've
+          # required 'open-uri'
+          OpenURI.open_uri(url) {|io| expand_and_parse(gemfile, io) }
           return true
         rescue OpenURI::HTTPError
           nil # noop

data/lib/yard/cli/server.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module YARD
   module CLI
     # A local documentation server
@@ -58,11 +59,13 @@ module YARD
 
       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
@@ -129,7 +132,8 @@ module YARD
         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)]
+          libraries[spec.name] |= [YARD::Server::LibraryVersion.new(spec.name, spec.version.to_s,
+                                                                    nil, :gem)]
         end
       end
 
@@ -139,7 +143,8 @@ module YARD
         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)]
+            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"
@@ -171,7 +176,8 @@ module YARD
         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|
+        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',
@@ -192,23 +198,26 @@ module YARD
         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
+        opts.on('-a', '--adapter ADAPTER',
+                'Use the ADAPTER (full Ruby class) for web server') do |adapter|
+          self.adapter = if adapter.casecmp('webrick') == 0
+                           YARD::Server::WebrickAdapter
+                         elsif adapter.casecmp('rack') == 0
+                           YARD::Server::RackAdapter
+                         else
+                           eval(adapter) # rubocop:disable Security/Eval
+                         end
         end
-        opts.on('-s', '--server TYPE', 'Use a specific server type eg. thin,mongrel,cgi (Rack specific)') do |type|
+        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|
+        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)

data/lib/yard/code_objects/method_object.rb

@@ -145,7 +145,7 @@ module YARD::CodeObjects
     end
 
     # Returns all alias names of the object
-    # @return [Array<Symbol>] the alias names
+    # @return [Array<MethodObject>] the alias names
     def aliases
       list = []
       return list unless namespace.is_a?(NamespaceObject)

data/lib/yard/code_objects/namespace_mapper.rb

@@ -11,6 +11,9 @@ module YARD
       # Registers a separator with an optional set of valid types that
       # must follow the separator lexically.
       #
+      # Calls all callbacks defined by {NamespaceMapper.on_invalidate} after
+      # the separator is registered.
+      #
       # @param sep [String] the separator string for the namespace
       # @param valid_types [Array<Symbol>] a list of object types that
       #   must follow the separator. If the list is empty, any type can
@@ -20,6 +23,7 @@ module YARD
       #   register_separator "#", :method
       #   # Anything after a "." denotes a method object
       #   register_separator ".", :method
+      # @see .on_invalidate
       def register_separator(sep, *valid_types)
         NamespaceMapper.invalidate
 
@@ -32,6 +36,19 @@ module YARD
         NamespaceMapper.map[sep] += valid_types
       end
 
+      # Unregisters a separator by a type.
+      #
+      # @param type [Symbol] the type to unregister
+      # @see #register_separator
+      def unregister_separator_by_type(type)
+        seps = NamespaceMapper.rev_map[type]
+        return unless seps
+        
+        seps.each {|s| NamespaceMapper.map.delete(s) }
+        NamespaceMapper.rev_map.delete(type)
+        NamespaceMapper.invalidate
+      end
+
       # Clears the map of separators.
       #
       # @return [void]
@@ -50,6 +67,7 @@ module YARD
       #   default_separator "::"
       def default_separator(value = nil)
         if value
+          NamespaceMapper.invalidate
           NamespaceMapper.default_separator = Regexp.quote value
         else
           NamespaceMapper.default_separator
@@ -71,17 +89,25 @@ module YARD
       # @param sep [String] the separator to return types for
       # @return [Array<Symbol>] a list of types registered to a separator
       def types_for_separator(sep)
-        NamespaceMapper.map[sep]
+        NamespaceMapper.map[sep] || []
       end
 
       # @param type [String] the type to return separators for
       # @return [Array<Symbol>] a list of separators registered to a type
       def separators_for_type(type)
-        NamespaceMapper.rev_map[type]
+        NamespaceMapper.rev_map[type] || []
       end
 
       # Internal methods to act as a singleton registry
       class << self
+        # @!group Invalidation callbacks
+
+        # Adds a callback that triggers when a new separator is registered or
+        # the cache is cleared by invalidation.
+        def on_invalidate(&block)
+          (@invalidation_callbacks ||= []).push(block)
+        end
+
         # @!visibility private
 
         # @return [Hash] a mapping of types to separators
@@ -98,11 +124,12 @@ module YARD
         # @return [void]
         def invalidate
           @map_match = nil
+          (@invalidation_callbacks || []).each(&:call)
         end
 
         # @return [Regexp] the full list of separators as a regexp match
         def map_match
-          @map_match ||= @map.keys.map {|k| Regexp.quote k }.join('|')
+          @map_match ||= map.keys.map {|k| Regexp.quote k }.join('|')
         end
 
         # @return [String] the default separator when no separator can begin

data/lib/yard/code_objects/proxy.rb

@@ -59,7 +59,8 @@ module YARD
 
         if @namespace.is_a?(ConstantObject)
           unless @namespace.value =~ /\A#{NAMESPACEMATCH}\Z/
-            raise Parser::UndocumentableError, "constant mapping"
+            raise Parser::UndocumentableError, "constant mapping for " +
+              "#{@origname} (type=#{type.inspect})"
           end
 
           @origname = nil # forget these for a constant

data/lib/yard/globals.rb

@@ -5,7 +5,7 @@
 #
 # @see YARD::CodeObjects::Proxy
 # @see YARD::Registry.resolve
-def P(namespace, name = nil, type = nil) # rubocop:disable Style/MethodName
+def P(namespace, name = nil, type = nil) # rubocop:disable Naming/MethodName
   if name.nil?
     name = namespace
     namespace = nil

data/lib/yard/handlers/c/base.rb

@@ -63,6 +63,13 @@ module YARD
 
         def namespace_for_variable(var)
           return namespaces[var] if namespaces[var]
+
+          # The global variables for Ruby's core error classes does not
+          # represent their Ruby name. So we need to look up these names.
+          name = ERROR_CLASS_NAMES[var]
+          return P(name) if name
+
+          # Otherwise the name is inferred from the C variable name.
           var = remove_var_prefix(var)
           var.empty? ? nil : P(var)
         end
@@ -120,6 +127,34 @@ module YARD
 
         private
 
+        # Generated by update_error_map.rb (Copy+past results)
+        ERROR_CLASS_NAMES = {
+          'rb_eArgError' => 'ArgumentError',
+          'rb_eEncodingError' => 'EncodingError',
+          'rb_eException' => 'Exception',
+          'rb_eFatal' => 'fatal',
+          'rb_eFrozenError' => 'FrozenError',
+          'rb_eIndexError' => 'IndexError',
+          'rb_eInterrupt' => 'Interrupt',
+          'rb_eKeyError' => 'KeyError',
+          'rb_eLoadError' => 'LoadError',
+          'rb_eNameError' => 'NameError',
+          'rb_eNoMatchingPatternError' => 'NoMatchingPatternError',
+          'rb_eNoMemError' => 'NoMemoryError',
+          'rb_eNoMethodError' => 'NoMethodError',
+          'rb_eNotImpError' => 'NotImplementedError',
+          'rb_eRangeError' => 'RangeError',
+          'rb_eRuntimeError' => 'RuntimeError',
+          'rb_eScriptError' => 'ScriptError',
+          'rb_eSecurityError' => 'SecurityError',
+          'rb_eSignal' => 'SignalException',
+          'rb_eStandardError' => 'StandardError',
+          'rb_eSyntaxError' => 'SyntaxError',
+          'rb_eSystemCallError' => 'SystemCallError',
+          'rb_eSystemExit' => 'SystemExit',
+          'rb_eTypeError' => 'TypeError',
+        }
+
         def remove_var_prefix(var)
           var.gsub(/^rb_[mc]|^[a-z_]+/, '')
         end

data/lib/yard/handlers/ruby/mixin_handler.rb

@@ -2,6 +2,7 @@
 # Handles the 'include' statement to mixin a module in the instance scope
 class YARD::Handlers::Ruby::MixinHandler < YARD::Handlers::Ruby::Base
   handles method_call(:include)
+  handles method_call(:prepend)
   namespace_only
 
   process do
@@ -34,7 +35,9 @@ class YARD::Handlers::Ruby::MixinHandler < YARD::Handlers::Ruby::Base
 
     rec = recipient(mixin)
     return if rec.nil? || rec.mixins(scope).include?(obj)
-    rec.mixins(scope).unshift(obj)
+
+    shift = statement.method_name(true) == :include ? :unshift : :push
+    rec.mixins(scope).send(shift, obj)
   end
 
   def recipient(mixin)

data/lib/yard/parser/ruby/legacy/irb/slex.rb

@@ -12,7 +12,7 @@
 
 require "irb/notifier"
 
-# :stopdoc:
+# @private
 module IRB
   class SLex
     DOUT = Notifier::def_notifier("SLex::")

data/lib/yard/parser/ruby/ruby_parser.rb

@@ -202,8 +202,7 @@ module YARD
             begin; undef on_#{event}; rescue NameError; end
             def on_#{event}(tok)
               unless @last_ns_token == [:kw, "def"] ||
-                  (@tokens.last && @tokens.last[0] == :symbeg) ||
-                  (!@newline && %w(if while until unless).include?(tok))
+                  (@tokens.last && @tokens.last[0] == :symbeg)
                 (@map[tok] ||= []) << [lineno, charno]
               end
               visit_ns_token(:#{event}, tok, true)
@@ -412,7 +411,7 @@ module YARD
         end
 
         def on_dyna_symbol(sym)
-          rng = if sym.source_range.size == 0 # rubocop:disable Style/ZeroLengthPredicate
+          rng = if sym.source_range.to_a.size == 0 # rubocop:disable Style/ZeroLengthPredicate
                   (sym.source_range.begin - 3)...sym.source_range.end
                 else
                   (sym.source_range.begin - 2)..(sym.source_range.end + 1)
@@ -442,6 +441,8 @@ module YARD
           module_eval(<<-eof, __FILE__, __LINE__ + 1)
             begin; undef on_#{kw}; rescue NameError; end
             def on_#{kw}(*args)
+              mapping = @map[#{kw.to_s.sub(/_mod$/, '').inspect}]
+              mapping.pop if mapping
               sr = args.last.source_range.first..args.first.source_range.last
               lr = args.last.line_range.first..args.first.line_range.last
               #{node_class}.new(:#{kw}, args, :line => lr, :char => sr)
@@ -612,7 +613,7 @@ module YARD
 
         def insert_comments
           root.traverse do |node|
-            next if %i{comment void_stmt list}.include?(node.type) || node.parent.type != :list
+            next if [:comment, :void_stmt, :list].include?(node.type) || node.parent.type != :list
 
             # never attach comments to if/unless mod nodes
             if node.type == :if_mod || node.type == :unless_mod
@@ -684,6 +685,7 @@ module YARD
         end
 
         def freeze_tree(node = nil)
+          @tokens = @tokens.sort_by {|t| t.last }
           nodes = [node || root]
           until nodes.empty?
             p_node = nodes.shift

data/lib/yard/parser/ruby/token_resolver.rb

@@ -7,6 +7,7 @@ module YARD
       # constant or identifier token.
       class TokenResolver
         include Enumerable
+        include CodeObjects::NamespaceMapper
 
         # Creates a token resolver for given source.
         #
@@ -114,7 +115,8 @@ module YARD
 
           if toktype == :const
             types.any? do |type|
-              prefix = (type ? type.path : "") + last_sep.to_s
+              prefix = type ? type.path : ""
+              prefix += last_sep.to_s if separators.include?(last_sep.to_s)
               self.object = Registry.resolve(@default_namespace, "#{prefix}#{name}", true)
             end
           else # ident

data/lib/yard/parser/source_parser.rb

@@ -64,7 +64,7 @@ module YARD
     class SourceParser
       SHEBANG_LINE  = /\A\s*#!\S+/
       ENCODING_LINE = %r{\A(?:\s*#*!.*\r?\n)?\s*(?:#+|/\*+|//+).*coding\s*[:=]{1,2}\s*([a-z\d_\-]+)}i
-      FROZEN_STRING_LINE = /frozen(-|_)string(-|_)literal: true/i
+      FROZEN_STRING_LINE = /frozen(-|_)string(-|_)literal:\s+(true|false)/i
 
       # The default glob of files to be parsed.
       # @since 0.9.0

data/lib/yard/registry_resolver.rb

@@ -16,6 +16,9 @@ module YARD
     def initialize(registry = Registry)
       @registry = registry
       @default_sep = nil
+
+      # Preload all code objects for separator declarations
+      YARD::CodeObjects.constants.map {|t| YARD::CodeObjects.const_get(t) }
     end
 
     # Performs a lookup on a given path in the registry. Resolution will occur
@@ -186,46 +189,29 @@ module YARD
       nss
     end
 
-    # @see NamespaceMapper#register_separator
-    def register_separator(*)
-      super
-      invalidate_memoized_matchers
-    end
-
-    # @see NamespaceMapper#clear_separators
-    def clear_separators
-      super
-      invalidate_memoized_matchers
-    end
-
-    # @see NamespaceMapper#default_separator
-    def default_separator(value = nil)
-      @starts_with_default_separator_match = nil if value
-      super
-    end
-
     # @return [Regexp] the regexp match of the default separator
     def starts_with_default_separator_match
-      @starts_with_default_separator_match ||= /\A#{default_separator}/
+      @@starts_with_default_separator_match ||= /\A#{default_separator}/
     end
 
     # @return [Regexp] the regexp that matches strings starting with
     #   a separator
     def starts_with_separator_match
-      @starts_with_separator_match ||= /\A(#{separators_match})/
+      @@starts_with_separator_match ||= /\A(#{separators_match})/
     end
 
     # @return [Regexp] the regexp that can be used to split a string on all
     #   occurrences of separator tokens
     def split_on_separators_match
-      @split_on_separators_match ||= /(.+?)(#{separators_match}|$)/
+      @@split_on_separators_match ||= /(.+?)(#{separators_match}|$)/
     end
 
     # Additional invalidations to done when NamespaceMapper API methods are
     # called on this class
-    def invalidate_memoized_matchers
-      @starts_with_separator_match = nil
-      @split_on_separators_match = nil
+    YARD::CodeObjects::NamespaceMapper.on_invalidate do
+      @@starts_with_default_separator_match = nil
+      @@starts_with_separator_match = nil
+      @@split_on_separators_match = nil
     end
   end
 end

data/lib/yard/registry_store.rb

@@ -291,7 +291,7 @@ module YARD
     def load_checksums
       return unless File.file?(checksums_path)
       lines = File.readlines(checksums_path).map do |line|
-        line.strip.split(/\s+/)
+        line.strip.rpartition(' ').tap { |p| p.delete_at(1) }
       end
       @checksums = Hash[lines]
     end

data/lib/yard/serializers/yardoc_serializer.rb

@@ -77,7 +77,7 @@ module YARD
               p.gsub(/[^\w\.-]/) do |x|
                 encoded = '_'
 
-                x.each_byte {|b| encoded << ("%X" % b) }
+                x.each_byte {|b| encoded += ("%X" % b) }
                 encoded
               end
             end.join('/') + '.' + extension