yard 0.9.18 → 0.9.19

data/lib/yard/rubygems/specification.rb

@@ -1,50 +1,50 @@
-# frozen_string_literal: true
-require 'rubygems/specification'
-
-class Gem::Specification
-  # @since 0.5.3
-  def has_yardoc=(value)
-    @has_rdoc = value ? 'yard' : false
-  end
-
-  def has_yardoc
-    @has_rdoc == 'yard'
-  end
-
-  undef has_rdoc?
-  def has_rdoc?
-    (@has_rdoc ||= true) && @has_rdoc != 'yard'
-  end
-
-  alias has_yardoc? has_yardoc
-
-  # has_rdoc should not be ignored!
-  if respond_to?(:overwrite_accessor)
-    overwrite_accessor(:has_rdoc) { @has_rdoc ||= true }
-    overwrite_accessor(:has_rdoc=) {|v| @has_rdoc = v }
-  else
-    attr_accessor :has_rdoc
-  end
-
-  if defined?(Gem::VERSION) && Gem::VERSION >= '1.7.'
-    def _dump_with_rdoc(limit)
-      dmp = _dump_without_rdoc(limit)
-      dmp[15] = @has_rdoc if dmp[15] == true
-      dmp
-    end
-    alias _dump_without_rdoc _dump
-    alias _dump _dump_with_rdoc
-
-    if class_variable_defined?(:@@default_value)
-      if @@default_value.frozen?
-        t = @@default_value.dup
-        t[:has_rdoc] = true
-        @@default_value = t.freeze
-      else
-        @@default_value[:has_rdoc] = true
-      end
-    end
-    @@attributes << 'has_rdoc' if class_variable_defined?(:@@attributes)
-    @@nil_attributes << 'has_rdoc' if class_variable_defined?(:@@nil_attributes)
-  end
-end
+# frozen_string_literal: true
+require 'rubygems/specification'
+
+class Gem::Specification
+  # @since 0.5.3
+  def has_yardoc=(value)
+    @has_rdoc = value ? 'yard' : false
+  end
+
+  def has_yardoc
+    @has_rdoc == 'yard'
+  end
+
+  undef has_rdoc?
+  def has_rdoc?
+    (@has_rdoc ||= true) && @has_rdoc != 'yard'
+  end
+
+  alias has_yardoc? has_yardoc
+
+  # has_rdoc should not be ignored!
+  if respond_to?(:overwrite_accessor)
+    overwrite_accessor(:has_rdoc) { @has_rdoc ||= true }
+    overwrite_accessor(:has_rdoc=) {|v| @has_rdoc = v }
+  else
+    attr_accessor :has_rdoc
+  end
+
+  if defined?(Gem::VERSION) && Gem::VERSION >= '1.7.'
+    def _dump_with_rdoc(limit)
+      dmp = _dump_without_rdoc(limit)
+      dmp[15] = @has_rdoc if dmp[15] == true
+      dmp
+    end
+    alias _dump_without_rdoc _dump
+    alias _dump _dump_with_rdoc
+
+    if class_variable_defined?(:@@default_value)
+      if @@default_value.frozen?
+        t = @@default_value.dup
+        t[:has_rdoc] = true
+        @@default_value = t.freeze
+      else
+        @@default_value[:has_rdoc] = true
+      end
+    end
+    @@attributes << 'has_rdoc' if class_variable_defined?(:@@attributes)
+    @@nil_attributes << 'has_rdoc' if class_variable_defined?(:@@nil_attributes)
+  end
+end

data/lib/yard/serializers/base.rb

@@ -1,83 +1,83 @@
-# frozen_string_literal: true
-module YARD
-  module Serializers
-    # The abstract base serializer. Serializers allow templates to be
-    # rendered to various endpoints. For instance, a {FileSystemSerializer}
-    # would allow template contents to be written to the filesystem
-    #
-    # To implement a custom serializer, override the following methods:
-    # * {#serialize}
-    # * {#serialized_path}
-    #
-    # Optionally, a serializer can implement before and after filters:
-    # * {#before_serialize}
-    # * {#after_serialize}
-    #
-    # @abstract Override this class to implement a custom serializer.
-    class Base
-      # All serializer options are saved so they can be passed to other serializers.
-      #
-      # @return [SymbolHash] the serializer options
-      attr_reader :options
-
-      # @group Creating a New Serializer
-
-      # Creates a new serializer with options
-      #
-      # @param [Hash] opts the options to assign to {#options}
-      def initialize(opts = {})
-        @options = SymbolHash.new(false).update(opts)
-      end
-
-      # @group Serializing an Object
-
-      # Serializes an object.
-      #
-      # @abstract This method should implement the logic that serializes
-      #   +data+ to the respective endpoint. This method should also call
-      #   the before and after callbacks {#before_serialize} and {#after_serialize}
-      # @param [CodeObjects::Base, String] object the object to serialize the
-      #   data for. The object can also be a string (for non-object serialization)
-      # @param [String] data the contents that should be serialized
-      def serialize(object, data) end
-
-      # The serialized path of an object
-      #
-      # @abstract This method should return the path of the object on the
-      #   endpoint. For instance, for a file serializer, this should return
-      #   the filename that represents the object on disk.
-      # @param [CodeObjects::Base] object the object to return a path for
-      # @return [String] the serialized path of an object
-      def serialized_path(object) end
-
-      # Returns whether an object has been serialized
-      #
-      # @abstract This method should return whether the endpoint already exists.
-      #   For instance, a file system serializer would check if the file exists
-      #   on disk. You will most likely use +#basepath+ and {#serialized_path} to
-      #   get the endpoint's location.
-      # @param [CodeObjects::Base] object the object to check existence of
-      # @return [Boolean] whether the endpoint exists.
-      # @since 0.6.0
-      def exists?(object) # rubocop:disable Lint/UnusedMethodArgument
-        false
-      end
-
-      # @group Callbacks
-
-      # Called before serialization.
-      #
-      # @abstract Should run code before serialization. Should return false
-      #   if serialization should not occur.
-      # @return [Boolean] whether or not serialization should occur
-      def before_serialize; end
-
-      # Called after serialization.
-      #
-      # @abstract Should run code after serialization.
-      # @param [String] data the data that was serialized.
-      # @return [void]
-      def after_serialize(data); end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Serializers
+    # The abstract base serializer. Serializers allow templates to be
+    # rendered to various endpoints. For instance, a {FileSystemSerializer}
+    # would allow template contents to be written to the filesystem
+    #
+    # To implement a custom serializer, override the following methods:
+    # * {#serialize}
+    # * {#serialized_path}
+    #
+    # Optionally, a serializer can implement before and after filters:
+    # * {#before_serialize}
+    # * {#after_serialize}
+    #
+    # @abstract Override this class to implement a custom serializer.
+    class Base
+      # All serializer options are saved so they can be passed to other serializers.
+      #
+      # @return [SymbolHash] the serializer options
+      attr_reader :options
+
+      # @group Creating a New Serializer
+
+      # Creates a new serializer with options
+      #
+      # @param [Hash] opts the options to assign to {#options}
+      def initialize(opts = {})
+        @options = SymbolHash.new(false).update(opts)
+      end
+
+      # @group Serializing an Object
+
+      # Serializes an object.
+      #
+      # @abstract This method should implement the logic that serializes
+      #   +data+ to the respective endpoint. This method should also call
+      #   the before and after callbacks {#before_serialize} and {#after_serialize}
+      # @param [CodeObjects::Base, String] object the object to serialize the
+      #   data for. The object can also be a string (for non-object serialization)
+      # @param [String] data the contents that should be serialized
+      def serialize(object, data) end
+
+      # The serialized path of an object
+      #
+      # @abstract This method should return the path of the object on the
+      #   endpoint. For instance, for a file serializer, this should return
+      #   the filename that represents the object on disk.
+      # @param [CodeObjects::Base] object the object to return a path for
+      # @return [String] the serialized path of an object
+      def serialized_path(object) end
+
+      # Returns whether an object has been serialized
+      #
+      # @abstract This method should return whether the endpoint already exists.
+      #   For instance, a file system serializer would check if the file exists
+      #   on disk. You will most likely use +#basepath+ and {#serialized_path} to
+      #   get the endpoint's location.
+      # @param [CodeObjects::Base] object the object to check existence of
+      # @return [Boolean] whether the endpoint exists.
+      # @since 0.6.0
+      def exists?(object) # rubocop:disable Lint/UnusedMethodArgument
+        false
+      end
+
+      # @group Callbacks
+
+      # Called before serialization.
+      #
+      # @abstract Should run code before serialization. Should return false
+      #   if serialization should not occur.
+      # @return [Boolean] whether or not serialization should occur
+      def before_serialize; end
+
+      # Called after serialization.
+      #
+      # @abstract Should run code after serialization.
+      # @param [String] data the data that was serialized.
+      # @return [void]
+      def after_serialize(data); end
+    end
+  end
+end

data/lib/yard/serializers/file_system_serializer.rb

@@ -1,123 +1,123 @@
-# frozen_string_literal: true
-module YARD
-  module Serializers
-    # Implements a serializer that reads from and writes to the filesystem.
-    class FileSystemSerializer < Base
-      # The base path to write data to.
-      # @return [String] a base path
-      attr_reader :basepath
-
-      def basepath=(value)
-        @basepath = options[:basepath] = value
-      end
-
-      # The extension of the filename (defaults to +html+)
-      #
-      # @return [String] the extension of the file. Empty string for no extension.
-      attr_reader :extension
-
-      def extension=(value)
-        @extension = options[:extension] = value
-      end
-
-      # Creates a new FileSystemSerializer with options
-      #
-      # @option opts [String] :basepath ('doc') the base path to write data to
-      # @option opts [String] :extension ('html') the extension of the serialized
-      #   path filename. If this is set to the empty string, no extension is used.
-      def initialize(opts = {})
-        super
-        @name_map = nil
-        @basepath = (options[:basepath] || 'doc').to_s
-        @extension = (options.key?(:extension) ? options[:extension] : 'html').to_s
-      end
-
-      # Serializes object with data to its serialized path (prefixed by the +#basepath+).
-      #
-      # @return [String] the written data (for chaining)
-      def serialize(object, data)
-        path = File.join(basepath, serialized_path(object))
-        log.debug "Serializing to #{path}"
-        File.open!(path, "wb") {|f| f.write data }
-      end
-
-      # Implements the serialized path of a code object.
-      #
-      # @param [CodeObjects::Base, CodeObjects::ExtraFileObject, String] object
-      #   the object to get a path for. The path of a string is the string itself.
-      # @return [String] if object is a String, returns
-      #   object, otherwise the path on disk (without the basepath).
-      def serialized_path(object)
-        return object if object.is_a?(String)
-
-        if object.is_a?(CodeObjects::ExtraFileObject)
-          fspath = ['file.' + object.name + (extension.empty? ? '' : ".#{extension}")]
-        else
-          objname = object != YARD::Registry.root ? mapped_name(object) : "top-level-namespace"
-          objname += '_' + object.scope.to_s[0, 1] if object.is_a?(CodeObjects::MethodObject)
-          fspath = [objname + (extension.empty? ? '' : ".#{extension}")]
-          if object.namespace && object.namespace.path != ""
-            fspath.unshift(*object.namespace.path.split(CodeObjects::NSEP))
-          end
-        end
-
-        File.join(encode_path_components(*fspath))
-      end
-
-      # Checks the disk for an object and returns whether it was serialized.
-      #
-      # @param [CodeObjects::Base] object the object to check
-      # @return [Boolean] whether an object has been serialized to disk
-      def exists?(object)
-        File.exist?(File.join(basepath, serialized_path(object)))
-      end
-
-      private
-
-      # Builds a filename mapping from object paths to filesystem path names.
-      # Needed to handle case sensitive YARD objects mapped into a case
-      # insensitive filesystem. Uses with {#mapped_name} to determine the
-      # mapping name for a given object.
-      #
-      # @note In order to use filesystem name mapping, you must initialize
-      #   the serializer object after preparing the {YARD::Registry}.
-      def build_filename_map
-        @name_map = {}
-        YARD::Registry.all.each do |object|
-          lpath = nil
-          if object.parent && object.parent.type != :root
-            lpath = object.parent.path + "::" + object.name.to_s.downcase
-          else
-            lpath = object.path.downcase
-          end
-
-          @name_map[lpath] ||= {}
-          size = @name_map[lpath].size
-          name = "#{object.name}#{size > 0 ? "_" * size : ""}"
-          @name_map[lpath][object.name] = name
-        end
-      end
-
-      # @return [String] the filesystem mapped name of a given object.
-      def mapped_name(object)
-        build_filename_map unless @name_map
-        map = @name_map[object.path.downcase]
-        map && map[object.name] ? map[object.name] : object.name.to_s
-      end
-
-      # Remove special chars from filenames.
-      # Windows disallows \ / : * ? " < > | but we will just remove any
-      # non alphanumeric (plus period, underscore and dash).
-      def encode_path_components(*components)
-        components.map! do |p|
-          p.gsub(/[^\w\.-]/) do |x|
-            encoded = String.new('_')
-
-            x.each_byte {|b| encoded << ("%X" % b) }
-            encoded
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Serializers
+    # Implements a serializer that reads from and writes to the filesystem.
+    class FileSystemSerializer < Base
+      # The base path to write data to.
+      # @return [String] a base path
+      attr_reader :basepath
+
+      def basepath=(value)
+        @basepath = options[:basepath] = value
+      end
+
+      # The extension of the filename (defaults to +html+)
+      #
+      # @return [String] the extension of the file. Empty string for no extension.
+      attr_reader :extension
+
+      def extension=(value)
+        @extension = options[:extension] = value
+      end
+
+      # Creates a new FileSystemSerializer with options
+      #
+      # @option opts [String] :basepath ('doc') the base path to write data to
+      # @option opts [String] :extension ('html') the extension of the serialized
+      #   path filename. If this is set to the empty string, no extension is used.
+      def initialize(opts = {})
+        super
+        @name_map = nil
+        @basepath = (options[:basepath] || 'doc').to_s
+        @extension = (options.key?(:extension) ? options[:extension] : 'html').to_s
+      end
+
+      # Serializes object with data to its serialized path (prefixed by the +#basepath+).
+      #
+      # @return [String] the written data (for chaining)
+      def serialize(object, data)
+        path = File.join(basepath, serialized_path(object))
+        log.debug "Serializing to #{path}"
+        File.open!(path, "wb") {|f| f.write data }
+      end
+
+      # Implements the serialized path of a code object.
+      #
+      # @param [CodeObjects::Base, CodeObjects::ExtraFileObject, String] object
+      #   the object to get a path for. The path of a string is the string itself.
+      # @return [String] if object is a String, returns
+      #   object, otherwise the path on disk (without the basepath).
+      def serialized_path(object)
+        return object if object.is_a?(String)
+
+        if object.is_a?(CodeObjects::ExtraFileObject)
+          fspath = ['file.' + object.name + (extension.empty? ? '' : ".#{extension}")]
+        else
+          objname = object != YARD::Registry.root ? mapped_name(object) : "top-level-namespace"
+          objname += '_' + object.scope.to_s[0, 1] if object.is_a?(CodeObjects::MethodObject)
+          fspath = [objname + (extension.empty? ? '' : ".#{extension}")]
+          if object.namespace && object.namespace.path != ""
+            fspath.unshift(*object.namespace.path.split(CodeObjects::NSEP))
+          end
+        end
+
+        File.join(encode_path_components(*fspath))
+      end
+
+      # Checks the disk for an object and returns whether it was serialized.
+      #
+      # @param [CodeObjects::Base] object the object to check
+      # @return [Boolean] whether an object has been serialized to disk
+      def exists?(object)
+        File.exist?(File.join(basepath, serialized_path(object)))
+      end
+
+      private
+
+      # Builds a filename mapping from object paths to filesystem path names.
+      # Needed to handle case sensitive YARD objects mapped into a case
+      # insensitive filesystem. Uses with {#mapped_name} to determine the
+      # mapping name for a given object.
+      #
+      # @note In order to use filesystem name mapping, you must initialize
+      #   the serializer object after preparing the {YARD::Registry}.
+      def build_filename_map
+        @name_map = {}
+        YARD::Registry.all.each do |object|
+          lpath = nil
+          if object.parent && object.parent.type != :root
+            lpath = object.parent.path + "::" + object.name.to_s.downcase
+          else
+            lpath = object.path.downcase
+          end
+
+          @name_map[lpath] ||= {}
+          size = @name_map[lpath].size
+          name = "#{object.name}#{size > 0 ? "_" * size : ""}"
+          @name_map[lpath][object.name] = name
+        end
+      end
+
+      # @return [String] the filesystem mapped name of a given object.
+      def mapped_name(object)
+        build_filename_map unless @name_map
+        map = @name_map[object.path.downcase]
+        map && map[object.name] ? map[object.name] : object.name.to_s
+      end
+
+      # Remove special chars from filenames.
+      # Windows disallows \ / : * ? " < > | but we will just remove any
+      # non alphanumeric (plus period, underscore and dash).
+      def encode_path_components(*components)
+        components.map! do |p|
+          p.gsub(/[^\w\.-]/) do |x|
+            encoded = String.new('_')
+
+            x.each_byte {|b| encoded << ("%X" % b) }
+            encoded
+          end
+        end
+      end
+    end
+  end
+end