yard 0.9.18 → 0.9.19

data/lib/yard/code_objects/class_object.rb

@@ -1,146 +1,146 @@
-# frozen_string_literal: true
-module YARD::CodeObjects
-  register_separator NSEP, :class
-
-  # A ClassObject represents a Ruby class in source code. It is a {ModuleObject}
-  # with extra inheritance semantics through the superclass.
-  class ClassObject < NamespaceObject
-    # The {ClassObject} that this class object inherits from in Ruby source.
-    # @return [ClassObject] a class object that is the superclass of this one
-    attr_reader :superclass
-
-    # Creates a new class object in +namespace+ with +name+
-    #
-    # @see Base.new
-    def initialize(namespace, name, *args, &block)
-      super
-
-      if is_exception?
-        self.superclass ||= "::Exception" unless P(namespace, name) == P(:Exception)
-      else
-        case P(namespace, name).path
-        when "BasicObject"
-          nil
-        when "Object"
-          self.superclass ||= "::BasicObject"
-        else
-          self.superclass ||= "::Object"
-        end
-      end
-    end
-
-    # Whether or not the class is a Ruby Exception
-    #
-    # @return [Boolean] whether the object represents a Ruby exception
-    def is_exception?
-      inheritance_tree.reverse.any? {|o| BUILTIN_EXCEPTIONS_HASH.key? o.path }
-    end
-
-    # Returns the inheritance tree of the object including self.
-    #
-    # @param [Boolean] include_mods whether or not to include mixins in the
-    #   inheritance tree.
-    # @return [Array<NamespaceObject>] the list of code objects that make up
-    #   the inheritance tree.
-    def inheritance_tree(include_mods = false)
-      list = (include_mods ? mixins(:instance, :class) : [])
-      if superclass.is_a?(Proxy) || superclass.respond_to?(:inheritance_tree)
-        list += [superclass] unless superclass == P(:Object) || superclass == P(:BasicObject)
-      end
-      [self] + list.map do |m|
-        next m if m == self
-        next m unless m.respond_to?(:inheritance_tree)
-        m.inheritance_tree(include_mods)
-      end.flatten.uniq
-    end
-
-    # Returns the list of methods matching the options hash. Returns
-    # all methods if hash is empty.
-    #
-    # @param [Hash] opts the options hash to match
-    # @option opts [Boolean] :inherited (true) whether inherited methods should be
-    #   included in the list
-    # @option opts [Boolean] :included (true) whether mixed in methods should be
-    #   included in the list
-    # @return [Array<MethodObject>] the list of methods that matched
-    def meths(opts = {})
-      opts = SymbolHash[:inherited => true].update(opts)
-      list = super(opts)
-      list += inherited_meths(opts).reject do |o|
-        next(false) if opts[:all]
-        list.find {|o2| o2.name == o.name && o2.scope == o.scope }
-      end if opts[:inherited]
-      list
-    end
-
-    # Returns only the methods that were inherited.
-    #
-    # @return [Array<MethodObject>] the list of inherited method objects
-    def inherited_meths(opts = {})
-      inheritance_tree[1..-1].inject([]) do |list, superclass|
-        if superclass.is_a?(Proxy)
-          list
-        else
-          list += superclass.meths(opts).reject do |o|
-            next(false) if opts[:all]
-            child(:name => o.name, :scope => o.scope) ||
-              list.find {|o2| o2.name == o.name && o2.scope == o.scope }
-          end
-        end
-      end
-    end
-
-    # Returns the list of constants matching the options hash.
-    #
-    # @param [Hash] opts the options hash to match
-    # @option opts [Boolean] :inherited (true) whether inherited constant should be
-    #   included in the list
-    # @option opts [Boolean] :included (true) whether mixed in constant should be
-    #   included in the list
-    # @return [Array<ConstantObject>] the list of constant that matched
-    def constants(opts = {})
-      opts = SymbolHash[:inherited => true].update(opts)
-      super(opts) + (opts[:inherited] ? inherited_constants : [])
-    end
-
-    # Returns only the constants that were inherited.
-    #
-    # @return [Array<ConstantObject>] the list of inherited constant objects
-    def inherited_constants
-      inheritance_tree[1..-1].inject([]) do |list, superclass|
-        if superclass.is_a?(Proxy)
-          list
-        else
-          list += superclass.constants.reject do |o|
-            child(:name => o.name) || list.find {|o2| o2.name == o.name }
-          end
-        end
-      end
-    end
-
-    # Sets the superclass of the object
-    #
-    # @param [Base, Proxy, String, Symbol, nil] object the superclass value
-    # @return [void]
-    def superclass=(object)
-      case object
-      when Base, Proxy, NilClass
-        @superclass = object
-      when String, Symbol
-        @superclass = Proxy.new(namespace, object)
-      else
-        raise ArgumentError, "superclass must be CodeObject, Proxy, String or Symbol"
-      end
-
-      if name == @superclass.name && namespace != YARD::Registry.root && !object.is_a?(Base)
-        @superclass = Proxy.new(namespace.namespace, object)
-      end
-
-      if @superclass == self
-        msg = "superclass #{@superclass.inspect} cannot be the same as the declared class #{inspect}"
-        @superclass = P("::Object")
-        raise ArgumentError, msg
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD::CodeObjects
+  register_separator NSEP, :class
+
+  # A ClassObject represents a Ruby class in source code. It is a {ModuleObject}
+  # with extra inheritance semantics through the superclass.
+  class ClassObject < NamespaceObject
+    # The {ClassObject} that this class object inherits from in Ruby source.
+    # @return [ClassObject] a class object that is the superclass of this one
+    attr_reader :superclass
+
+    # Creates a new class object in +namespace+ with +name+
+    #
+    # @see Base.new
+    def initialize(namespace, name, *args, &block)
+      super
+
+      if is_exception?
+        self.superclass ||= "::Exception" unless P(namespace, name) == P(:Exception)
+      else
+        case P(namespace, name).path
+        when "BasicObject"
+          nil
+        when "Object"
+          self.superclass ||= "::BasicObject"
+        else
+          self.superclass ||= "::Object"
+        end
+      end
+    end
+
+    # Whether or not the class is a Ruby Exception
+    #
+    # @return [Boolean] whether the object represents a Ruby exception
+    def is_exception?
+      inheritance_tree.reverse.any? {|o| BUILTIN_EXCEPTIONS_HASH.key? o.path }
+    end
+
+    # Returns the inheritance tree of the object including self.
+    #
+    # @param [Boolean] include_mods whether or not to include mixins in the
+    #   inheritance tree.
+    # @return [Array<NamespaceObject>] the list of code objects that make up
+    #   the inheritance tree.
+    def inheritance_tree(include_mods = false)
+      list = (include_mods ? mixins(:instance, :class) : [])
+      if superclass.is_a?(Proxy) || superclass.respond_to?(:inheritance_tree)
+        list += [superclass] unless superclass == P(:Object) || superclass == P(:BasicObject)
+      end
+      [self] + list.map do |m|
+        next m if m == self
+        next m unless m.respond_to?(:inheritance_tree)
+        m.inheritance_tree(include_mods)
+      end.flatten.uniq
+    end
+
+    # Returns the list of methods matching the options hash. Returns
+    # all methods if hash is empty.
+    #
+    # @param [Hash] opts the options hash to match
+    # @option opts [Boolean] :inherited (true) whether inherited methods should be
+    #   included in the list
+    # @option opts [Boolean] :included (true) whether mixed in methods should be
+    #   included in the list
+    # @return [Array<MethodObject>] the list of methods that matched
+    def meths(opts = {})
+      opts = SymbolHash[:inherited => true].update(opts)
+      list = super(opts)
+      list += inherited_meths(opts).reject do |o|
+        next(false) if opts[:all]
+        list.find {|o2| o2.name == o.name && o2.scope == o.scope }
+      end if opts[:inherited]
+      list
+    end
+
+    # Returns only the methods that were inherited.
+    #
+    # @return [Array<MethodObject>] the list of inherited method objects
+    def inherited_meths(opts = {})
+      inheritance_tree[1..-1].inject([]) do |list, superclass|
+        if superclass.is_a?(Proxy)
+          list
+        else
+          list += superclass.meths(opts).reject do |o|
+            next(false) if opts[:all]
+            child(:name => o.name, :scope => o.scope) ||
+              list.find {|o2| o2.name == o.name && o2.scope == o.scope }
+          end
+        end
+      end
+    end
+
+    # Returns the list of constants matching the options hash.
+    #
+    # @param [Hash] opts the options hash to match
+    # @option opts [Boolean] :inherited (true) whether inherited constant should be
+    #   included in the list
+    # @option opts [Boolean] :included (true) whether mixed in constant should be
+    #   included in the list
+    # @return [Array<ConstantObject>] the list of constant that matched
+    def constants(opts = {})
+      opts = SymbolHash[:inherited => true].update(opts)
+      super(opts) + (opts[:inherited] ? inherited_constants : [])
+    end
+
+    # Returns only the constants that were inherited.
+    #
+    # @return [Array<ConstantObject>] the list of inherited constant objects
+    def inherited_constants
+      inheritance_tree[1..-1].inject([]) do |list, superclass|
+        if superclass.is_a?(Proxy)
+          list
+        else
+          list += superclass.constants.reject do |o|
+            child(:name => o.name) || list.find {|o2| o2.name == o.name }
+          end
+        end
+      end
+    end
+
+    # Sets the superclass of the object
+    #
+    # @param [Base, Proxy, String, Symbol, nil] object the superclass value
+    # @return [void]
+    def superclass=(object)
+      case object
+      when Base, Proxy, NilClass
+        @superclass = object
+      when String, Symbol
+        @superclass = Proxy.new(namespace, object)
+      else
+        raise ArgumentError, "superclass must be CodeObject, Proxy, String or Symbol"
+      end
+
+      if name == @superclass.name && namespace != YARD::Registry.root && !object.is_a?(Base)
+        @superclass = Proxy.new(namespace.namespace, object)
+      end
+
+      if @superclass == self
+        msg = "superclass #{@superclass.inspect} cannot be the same as the declared class #{inspect}"
+        @superclass = P("::Object")
+        raise ArgumentError, msg
+      end
+    end
+  end
+end

data/lib/yard/code_objects/class_variable_object.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-module YARD::CodeObjects
-  register_separator NSEP, :class_variable
-
-  # Represents a class variable inside a namespace. The path is expressed
-  # in the form "A::B::@@classvariable"
-  class ClassVariableObject < Base
-    # @return [String] the class variable's value
-    attr_accessor :value
-  end
-end
+# frozen_string_literal: true
+module YARD::CodeObjects
+  register_separator NSEP, :class_variable
+
+  # Represents a class variable inside a namespace. The path is expressed
+  # in the form "A::B::@@classvariable"
+  class ClassVariableObject < Base
+    # @return [String] the class variable's value
+    attr_accessor :value
+  end
+end

data/lib/yard/code_objects/constant_object.rb

@@ -1,16 +1,16 @@
-# frozen_string_literal: true
-module YARD::CodeObjects
-  register_separator NSEP, :constant
-
-  # A +ConstantObject+ represents a Ruby constant (not a module or class).
-  # To access the constant's (source code) value, use {#value}.
-  class ConstantObject < Base
-    # The source code representing the constant's value
-    # @return [String] the value the constant is set to
-    attr_reader :value
-
-    def value=(value)
-      @value = format_source(value)
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD::CodeObjects
+  register_separator NSEP, :constant
+
+  # A +ConstantObject+ represents a Ruby constant (not a module or class).
+  # To access the constant's (source code) value, use {#value}.
+  class ConstantObject < Base
+    # The source code representing the constant's value
+    # @return [String] the value the constant is set to
+    attr_reader :value
+
+    def value=(value)
+      @value = format_source(value)
+    end
+  end
+end

data/lib/yard/code_objects/extended_method_object.rb

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-module YARD::CodeObjects
-  # Represents an instance method of a module that was mixed into the class
-  # scope of another namespace.
-  #
-  # @see MethodObject
-  class ExtendedMethodObject
-    instance_methods.each {|m| undef_method(m) unless m =~ /^__/ || m.to_sym == :object_id }
-
-    # @return [Symbol] always +:class+
-    def scope; :class end
-
-    # Sets up a delegate for {MethodObject} obj.
-    #
-    # @param [MethodObject] obj the instance method to treat as a mixed in
-    #   class method on another namespace.
-    def initialize(obj) @del = obj end
-
-    # Sends all methods to the {MethodObject} assigned in {#initialize}
-    # @see #initialize
-    # @see MethodObject
-    def method_missing(sym, *args, &block) @del.__send__(sym, *args, &block) end
-  end
-end
+# frozen_string_literal: true
+module YARD::CodeObjects
+  # Represents an instance method of a module that was mixed into the class
+  # scope of another namespace.
+  #
+  # @see MethodObject
+  class ExtendedMethodObject
+    instance_methods.each {|m| undef_method(m) unless m =~ /^__/ || m.to_sym == :object_id }
+
+    # @return [Symbol] always +:class+
+    def scope; :class end
+
+    # Sets up a delegate for {MethodObject} obj.
+    #
+    # @param [MethodObject] obj the instance method to treat as a mixed in
+    #   class method on another namespace.
+    def initialize(obj) @del = obj end
+
+    # Sends all methods to the {MethodObject} assigned in {#initialize}
+    # @see #initialize
+    # @see MethodObject
+    def method_missing(sym, *args, &block) @del.__send__(sym, *args, &block) end
+  end
+end

data/lib/yard/code_objects/extra_file_object.rb

@@ -1,131 +1,134 @@
-# frozen_string_literal: true
-module YARD::CodeObjects
-  # An ExtraFileObject represents an extra documentation file (README or other
-  # file). It is not strictly a CodeObject (does not inherit from `Base`) although
-  # it implements `path`, `name` and `type`, and therefore should be structurally
-  # compatible with most CodeObject interfaces.
-  class ExtraFileObject
-    attr_accessor :filename
-    attr_writer :attributes
-    attr_accessor :name
-    # @since 0.8.3
-    attr_reader :locale
-
-    # Creates a new extra file object.
-    # @param [String] filename the location on disk of the file
-    # @param [String] contents the file contents. If not set, the contents
-    #   will be read from disk using the +filename+.
-    def initialize(filename, contents = nil)
-      self.filename = filename
-      self.name = File.basename(filename).gsub(/\.[^.]+$/, '')
-      self.attributes = SymbolHash.new(false)
-      @original_contents = contents
-      @parsed = false
-      @locale = nil
-      ensure_parsed
-    end
-
-    alias path name
-
-    def attributes
-      ensure_parsed
-      @attributes
-    end
-
-    def title
-      attributes[:title] || name
-    end
-
-    def contents
-      ensure_parsed
-      @contents
-    end
-
-    def contents=(contents)
-      @original_contents = contents
-      @parsed = false
-    end
-
-    # @param [String] locale the locale name to be translated.
-    # @return [void]
-    # @since 0.8.3
-    def locale=(locale)
-      @locale = locale
-      @parsed = false
-    end
-
-    def inspect
-      "#<yardoc #{type} #{filename} attrs=#{attributes.inspect}>"
-    end
-    alias to_s inspect
-
-    def type; :extra_file end
-
-    def ==(other)
-      return false unless self.class === other
-      other.filename == filename
-    end
-    alias eql? ==
-    alias equal? ==
-    def hash; filename.hash end
-
-    private
-
-    def ensure_parsed
-      return if @parsed
-      @parsed = true
-      @contents = parse_contents(@original_contents || File.read(@filename))
-    end
-
-    # @param [String] data the file contents
-    def parse_contents(data)
-      retried = false
-      cut_index = 0
-      data = translate(data)
-      data = data.split("\n")
-      data.each_with_index do |line, index|
-        case line
-        when /^#!(\S+)\s*$/
-          if index == 0
-            attributes[:markup] = $1
-          else
-            cut_index = index
-            break
-          end
-        when /^\s*#\s*@(\S+)\s*(.+?)\s*$/
-          attributes[$1] = $2
-        when /^\s*<!--\s*$/, /^\s*-->\s*$/
-          # Ignore HTML comments
-        else
-          cut_index = index
-          break
-        end
-      end
-      data = data[cut_index..-1] if cut_index > 0
-      contents = data.join("\n")
-
-      if contents.respond_to?(:force_encoding) && attributes[:encoding]
-        begin
-          contents.force_encoding(attributes[:encoding])
-        rescue ArgumentError
-          log.warn "Invalid encoding `#{attributes[:encoding]}' in #{filename}"
-        end
-      end
-      contents
-    rescue ArgumentError => e
-      if retried && e.message =~ /invalid byte sequence/
-        # This should never happen.
-        log.warn "Could not read #{filename}, #{e.message}. You probably want to set `--charset`."
-        return ''
-      end
-      data.force_encoding('binary') if data.respond_to?(:force_encoding)
-      retried = true
-      retry
-    end
-
-    def translate(data)
-      text = YARD::I18n::Text.new(data, :have_header => true)
-      text.translate(YARD::Registry.locale(locale))
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD::CodeObjects
+  # An ExtraFileObject represents an extra documentation file (README or other
+  # file). It is not strictly a CodeObject (does not inherit from `Base`) although
+  # it implements `path`, `name` and `type`, and therefore should be structurally
+  # compatible with most CodeObject interfaces.
+  class ExtraFileObject
+    attr_accessor :filename
+    attr_writer :attributes
+    attr_accessor :name
+    # @since 0.8.3
+    attr_reader :locale
+
+    # Creates a new extra file object.
+    # @param [String] filename the location on disk of the file
+    # @param [String] contents the file contents. If not set, the contents
+    #   will be read from disk using the +filename+.
+    def initialize(filename, contents = nil)
+      self.filename = filename
+      self.name = File.basename(filename).gsub(/\.[^.]+$/, '')
+      self.attributes = SymbolHash.new(false)
+      @original_contents = contents
+      @parsed = false
+      @locale = nil
+      ensure_parsed
+    end
+
+    alias path name
+
+    def attributes
+      ensure_parsed
+      @attributes
+    end
+
+    def title
+      attributes[:title] || name
+    end
+
+    def contents
+      ensure_parsed
+      @contents
+    end
+
+    def contents=(contents)
+      @original_contents = contents
+      @parsed = false
+    end
+
+    # @param [String] locale the locale name to be translated.
+    # @return [void]
+    # @since 0.8.3
+    def locale=(locale)
+      @locale = locale
+      @parsed = false
+    end
+
+    def inspect
+      "#<yardoc #{type} #{filename} attrs=#{attributes.inspect}>"
+    end
+    alias to_s inspect
+
+    def type; :extra_file end
+
+    def ==(other)
+      return false unless self.class === other
+      other.filename == filename
+    end
+    alias eql? ==
+    alias equal? ==
+    def hash; filename.hash end
+
+    private
+
+    def ensure_parsed
+      return if @parsed
+      @parsed = true
+      @contents = parse_contents(@original_contents || File.read(@filename))
+    end
+
+    # @param [String] data the file contents
+    def parse_contents(data)
+      retried = false
+      cut_index = 0
+      data = translate(data)
+      data = data.split("\n")
+      data.each_with_index do |line, index|
+        case line
+        when /^#!(\S+)\s*$/
+          if index == 0
+            attributes[:markup] = $1
+          else
+            cut_index = index
+            break
+          end
+        when /^\s*#\s*@(\S+)\s*(.+?)\s*$/
+          attributes[$1] = $2
+        when /^\s*<!--\s*$/, /^\s*-->\s*$/
+          # Ignore HTML comments
+        else
+          cut_index = index
+          break
+        end
+      end
+      data = data[cut_index..-1] if cut_index > 0
+      contents = data.join("\n")
+
+      if contents.respond_to?(:force_encoding) && attributes[:encoding]
+        begin
+          contents.force_encoding(attributes[:encoding])
+        rescue ArgumentError
+          log.warn "Invalid encoding `#{attributes[:encoding]}' in #{filename}"
+        end
+      end
+      contents
+    rescue ArgumentError => e
+      raise unless e.message =~ /invalid byte sequence/
+
+      if retried
+        # This should never happen.
+        log.warn "Could not read #{filename}, #{e.message}. You probably want to set `--charset`."
+        return ''
+      else
+        data.force_encoding('binary') if data.respond_to?(:force_encoding)
+        retried = true
+        retry
+      end
+    end
+
+    def translate(data)
+      text = YARD::I18n::Text.new(data, :have_header => true)
+      text.translate(YARD::Registry.locale(locale))
+    end
+  end
+end