yard 0.9.24 → 0.9.25

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/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

@@ -1,129 +1,164 @@
-# frozen_string_literal: true
-module YARD
-  module Handlers
-    module C
-      class Base < Handlers::Base
-        include YARD::Parser::C
-        include HandlerMethods
-
-        # @return [Boolean] whether the handler handles this statement
-        def self.handles?(statement, processor)
-          processor.globals.cruby_processed_files ||= {}
-          processor.globals.cruby_processed_files[processor.file] = true
-
-          src = statement.respond_to?(:declaration) ?
-            statement.declaration : statement.source
-
-          handlers.any? do |a_handler|
-            statement_class >= statement.class &&
-              case a_handler
-              when String
-                src == a_handler
-              when Regexp
-                src =~ a_handler
-              end
-          end
-        end
-
-        def self.statement_class(type = nil)
-          if type
-            @statement_class = type
-          else
-            (defined?(@statement_class) && @statement_class) || Statement
-          end
-        end
-
-        # @group Registering objects
-
-        def register_docstring(object, docstring = nil, stmt = nil)
-          super(object, docstring, stmt) if docstring
-        end
-
-        def register_file_info(object, file = nil, line = nil, comments = nil)
-          super(object, file, line, comments) if file
-        end
-
-        def register_source(object, source = nil, type = nil)
-          super(object, source, type) if source
-        end
-
-        def register_visibility(object, visibility = nil)
-          super(object, visibility) if visibility
-        end
-
-        # @group Looking up Symbol and Var Values
-
-        def symbols
-          globals.cruby_symbols ||= {}
-        end
-
-        def override_comments
-          globals.cruby_override_comments ||= []
-        end
-
-        def namespace_for_variable(var)
-          return namespaces[var] if namespaces[var]
-          var = remove_var_prefix(var)
-          var.empty? ? nil : P(var)
-        end
-
-        def ensure_variable_defined!(var, max_retries = 1)
-          retries = 0
-          object = nil
-
-          loop do
-            object = namespace_for_variable(var)
-            break unless object.is_a?(Proxy)
-
-            raise NamespaceMissingError, object if retries > max_retries
-            log.debug "Missing namespace variable #{var} in file `#{parser.file}', moving it to the back of the line."
-            parser.parse_remaining_files
-            retries += 1
-          end
-
-          object
-        end
-
-        def namespaces
-          globals.cruby_namespaces ||= {}
-        end
-
-        def processed_files
-          globals.cruby_processed_files ||= {}
-        end
-
-        # @group Parsing an Inner Block
-
-        def parse_block(opts = {})
-          return if !statement.block || statement.block.empty?
-          push_state(opts) do
-            parser.process(statement.block)
-          end
-        end
-
-        # @group Processing other files
-
-        def process_file(file, object)
-          file = File.cleanpath(file)
-          return if processed_files[file]
-          processed_files[file] = file
-          begin
-            log.debug "Processing embedded call to C source #{file}..."
-            globals.ordered_parser.files.delete(file) if globals.ordered_parser
-            parser.process(Parser::C::CParser.new(File.read(file), file).parse)
-          rescue Errno::ENOENT
-            log.warn "Missing source file `#{file}' when parsing #{object}"
-          end
-        end
-
-        # @endgroup
-
-        private
-
-        def remove_var_prefix(var)
-          var.gsub(/^rb_[mc]|^[a-z_]+/, '')
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Handlers
+    module C
+      class Base < Handlers::Base
+        include YARD::Parser::C
+        include HandlerMethods
+
+        # @return [Boolean] whether the handler handles this statement
+        def self.handles?(statement, processor)
+          processor.globals.cruby_processed_files ||= {}
+          processor.globals.cruby_processed_files[processor.file] = true
+
+          src = statement.respond_to?(:declaration) ?
+            statement.declaration : statement.source
+
+          handlers.any? do |a_handler|
+            statement_class >= statement.class &&
+              case a_handler
+              when String
+                src == a_handler
+              when Regexp
+                src =~ a_handler
+              end
+          end
+        end
+
+        def self.statement_class(type = nil)
+          if type
+            @statement_class = type
+          else
+            (defined?(@statement_class) && @statement_class) || Statement
+          end
+        end
+
+        # @group Registering objects
+
+        def register_docstring(object, docstring = nil, stmt = nil)
+          super(object, docstring, stmt) if docstring
+        end
+
+        def register_file_info(object, file = nil, line = nil, comments = nil)
+          super(object, file, line, comments) if file
+        end
+
+        def register_source(object, source = nil, type = nil)
+          super(object, source, type) if source
+        end
+
+        def register_visibility(object, visibility = nil)
+          super(object, visibility) if visibility
+        end
+
+        # @group Looking up Symbol and Var Values
+
+        def symbols
+          globals.cruby_symbols ||= {}
+        end
+
+        def override_comments
+          globals.cruby_override_comments ||= []
+        end
+
+        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
+
+        def ensure_variable_defined!(var, max_retries = 1)
+          retries = 0
+          object = nil
+
+          loop do
+            object = namespace_for_variable(var)
+            break unless object.is_a?(Proxy)
+
+            raise NamespaceMissingError, object if retries > max_retries
+            log.debug "Missing namespace variable #{var} in file `#{parser.file}', moving it to the back of the line."
+            parser.parse_remaining_files
+            retries += 1
+          end
+
+          object
+        end
+
+        def namespaces
+          globals.cruby_namespaces ||= {}
+        end
+
+        def processed_files
+          globals.cruby_processed_files ||= {}
+        end
+
+        # @group Parsing an Inner Block
+
+        def parse_block(opts = {})
+          return if !statement.block || statement.block.empty?
+          push_state(opts) do
+            parser.process(statement.block)
+          end
+        end
+
+        # @group Processing other files
+
+        def process_file(file, object)
+          file = File.cleanpath(file)
+          return if processed_files[file]
+          processed_files[file] = file
+          begin
+            log.debug "Processing embedded call to C source #{file}..."
+            globals.ordered_parser.files.delete(file) if globals.ordered_parser
+            parser.process(Parser::C::CParser.new(File.read(file), file).parse)
+          rescue Errno::ENOENT
+            log.warn "Missing source file `#{file}' when parsing #{object}"
+          end
+        end
+
+        # @endgroup
+
+        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
+      end
+    end
+  end
+end

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