yard 0.9.18 → 0.9.23

data/lib/yard/serializers/process_serializer.rb

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-module YARD
-  module Serializers
-    # Serializes an object to a process (like less)
-    #
-    # @example Serializing to a pager (less)
-    #   serializer = ProcessSerializer.new('less')
-    #   serializer.serialize(object, "data!")
-    class ProcessSerializer < Base
-      # Creates a new ProcessSerializer for the shell command +cmd+
-      #
-      # @param [String] cmd the command that will accept data on stdin
-      def initialize(cmd)
-        @cmd = cmd
-      end
-
-      # Overrides serialize behaviour and writes data to standard input
-      # of the associated command
-      def serialize(_object, data)
-        IO.popen(@cmd, 'w') {|io| io.write(data) }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Serializers
+    # Serializes an object to a process (like less)
+    #
+    # @example Serializing to a pager (less)
+    #   serializer = ProcessSerializer.new('less')
+    #   serializer.serialize(object, "data!")
+    class ProcessSerializer < Base
+      # Creates a new ProcessSerializer for the shell command +cmd+
+      #
+      # @param [String] cmd the command that will accept data on stdin
+      def initialize(cmd)
+        @cmd = cmd
+      end
+
+      # Overrides serialize behaviour and writes data to standard input
+      # of the associated command
+      def serialize(_object, data)
+        IO.popen(@cmd, 'w') {|io| io.write(data) }
+      end
+    end
+  end
+end

data/lib/yard/serializers/stdout_serializer.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-module YARD
-  module Serializers
-    # A serializer that writes data to standard output.
-    class StdoutSerializer < Base
-      # Creates a serializer to print text to stdout
-      #
-      # @param [Fixnum, nil] wrap if wrap is a number, wraps text to +wrap+
-      #   columns, otherwise no wrapping is done.
-      def initialize(wrap = nil)
-        @wrap = wrap
-      end
-
-      # Overrides serialize behaviour to write data to standard output
-      def serialize(_object, data)
-        print(@wrap ? word_wrap(data, @wrap) : data)
-      end
-
-      private
-
-      # Wraps text to a specific column length
-      #
-      # @param [String] text the text to wrap
-      # @param [Fixnum] _length the column length to wrap to
-      # @return [String] the wrapped text
-      def word_wrap(text, _length = 80)
-        # See ruby-talk/10655 / Ernest Ellingson
-        text.gsub(/\t/, "     ").gsub(/.{1,50}(?:\s|\Z)/) do
-          ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n")
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Serializers
+    # A serializer that writes data to standard output.
+    class StdoutSerializer < Base
+      # Creates a serializer to print text to stdout
+      #
+      # @param [Fixnum, nil] wrap if wrap is a number, wraps text to +wrap+
+      #   columns, otherwise no wrapping is done.
+      def initialize(wrap = nil)
+        @wrap = wrap
+      end
+
+      # Overrides serialize behaviour to write data to standard output
+      def serialize(_object, data)
+        print(@wrap ? word_wrap(data, @wrap) : data)
+      end
+
+      private
+
+      # Wraps text to a specific column length
+      #
+      # @param [String] text the text to wrap
+      # @param [Fixnum] _length the column length to wrap to
+      # @return [String] the wrapped text
+      def word_wrap(text, _length = 80)
+        # See ruby-talk/10655 / Ernest Ellingson
+        text.gsub(/\t/, "     ").gsub(/.{1,50}(?:\s|\Z)/) do
+          ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n")
+        end
+      end
+    end
+  end
+end

data/lib/yard/serializers/yardoc_serializer.rb

@@ -1,152 +1,152 @@
-# frozen_string_literal: true
-module YARD
-  # Stubs marshal dumps and acts a delegate class for an object by path
-  #
-  # @private
-  class StubProxy
-    instance_methods.each {|m| undef_method(m) unless m.to_s =~ /^__|^object_id$/ }
-
-    def _dump(_depth) @path end
-    def self._load(str) new(str) end
-    def hash; @path.hash end
-
-    def initialize(path, transient = false)
-      @path = path
-      @transient = transient
-    end
-
-    def method_missing(meth, *args, &block)
-      return true if meth == :respond_to? && args.first == :_dump
-      @object = nil if @transient
-      @object ||= Registry.at(@path)
-      @object.send(meth, *args, &block)
-    rescue NoMethodError => e
-      e.backtrace.delete_if {|l| l[0, FILELEN] == __FILE__ }
-      raise
-    end
-
-    FILELEN = __FILE__.size
-  end
-
-  module Serializers
-    class YardocSerializer < FileSystemSerializer
-      def initialize(yfile)
-        super(:basepath => yfile, :extension => 'dat')
-      end
-
-      def objects_path; File.join(basepath, 'objects') end
-      # @deprecated The registry no longer tracks proxy types
-      def proxy_types_path; File.join(basepath, 'proxy_types') end
-      def checksums_path; File.join(basepath, 'checksums') end
-      def object_types_path; File.join(basepath, 'object_types') end
-      def complete_lock_path; File.join(basepath, 'complete') end
-      def processing_path; File.join(basepath, 'processing') end
-
-      def complete?
-        File.exist?(complete_lock_path) && !locked_for_writing?
-      end
-
-      # Creates a pessmistic transactional lock on the database for writing.
-      # Use with {YARD.parse} to ensure the database is not written multiple
-      # times.
-      #
-      # @see #locked_for_writing?
-      def lock_for_writing
-        File.open!(processing_path, 'w') {}
-        yield
-      ensure
-        File.unlink(processing_path) if File.exist?(processing_path)
-      end
-
-      # @return [Boolean] whether the database is currently locked for writing
-      def locked_for_writing?
-        File.exist?(processing_path)
-      end
-
-      def serialized_path(object)
-        path =
-          case object
-          when String, Symbol
-            object = object.to_s
-            if object =~ /#/
-              object += '_i'
-            elsif object =~ /\./
-              object += '_c'
-            end
-            object.split(/::|\.|#/).map do |p|
-              p.gsub(/[^\w\.-]/) do |x|
-                encoded = '_'
-
-                x.each_byte {|b| encoded << ("%X" % b) }
-                encoded
-              end
-            end.join('/') + '.' + extension
-          when YARD::CodeObjects::RootObject
-            'root.dat'
-          else
-            super(object)
-          end
-
-        File.join('objects', path)
-      end
-
-      def serialize(object)
-        if Hash === object
-          super(object[:root], dump(object)) if object[:root]
-        else
-          super(object, dump(object))
-        end
-      end
-
-      def deserialize(path, is_path = false)
-        path = File.join(basepath, serialized_path(path)) unless is_path
-        if File.file?(path)
-          log.debug "Deserializing #{path}..."
-          Marshal.load(File.read_binary(path))
-        else
-          log.debug "Could not find #{path}"
-          nil
-        end
-      end
-
-      private
-
-      def dump(object)
-        object = internal_dump(object, true) unless object.is_a?(Hash)
-        Marshal.dump(object)
-      end
-
-      def internal_dump(object, first_object = false)
-        if !first_object && object.is_a?(CodeObjects::Base) &&
-           !(Tags::OverloadTag === object)
-          return StubProxy.new(object.path)
-        end
-
-        if object.is_a?(Hash) || object.is_a?(Array) ||
-           object.is_a?(CodeObjects::Base) ||
-           !object.instance_variables.empty?
-          object = object.dup
-        end
-
-        object.instance_variables.each do |ivar|
-          ivar_obj = object.instance_variable_get(ivar)
-          ivar_obj_dump = internal_dump(ivar_obj)
-          object.instance_variable_set(ivar, ivar_obj_dump)
-        end
-
-        case object
-        when Hash
-          list = object.map do |k, v|
-            [k, v].map {|item| internal_dump(item) }
-          end
-          object.replace(Hash[list])
-        when Array
-          list = object.map {|item| internal_dump(item) }
-          object.replace(list)
-        end
-
-        object
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  # Stubs marshal dumps and acts a delegate class for an object by path
+  #
+  # @private
+  class StubProxy
+    instance_methods.each {|m| undef_method(m) unless m.to_s =~ /^__|^object_id$/ }
+
+    def _dump(_depth) @path end
+    def self._load(str) new(str) end
+    def hash; @path.hash end
+
+    def initialize(path, transient = false)
+      @path = path
+      @transient = transient
+    end
+
+    def method_missing(meth, *args, &block)
+      return true if meth == :respond_to? && args.first == :_dump
+      @object = nil if @transient
+      @object ||= Registry.at(@path)
+      @object.send(meth, *args, &block)
+    rescue NoMethodError => e
+      e.backtrace.delete_if {|l| l[0, FILELEN] == __FILE__ }
+      raise
+    end
+
+    FILELEN = __FILE__.size
+  end
+
+  module Serializers
+    class YardocSerializer < FileSystemSerializer
+      def initialize(yfile)
+        super(:basepath => yfile, :extension => 'dat')
+      end
+
+      def objects_path; File.join(basepath, 'objects') end
+      # @deprecated The registry no longer tracks proxy types
+      def proxy_types_path; File.join(basepath, 'proxy_types') end
+      def checksums_path; File.join(basepath, 'checksums') end
+      def object_types_path; File.join(basepath, 'object_types') end
+      def complete_lock_path; File.join(basepath, 'complete') end
+      def processing_path; File.join(basepath, 'processing') end
+
+      def complete?
+        File.exist?(complete_lock_path) && !locked_for_writing?
+      end
+
+      # Creates a pessmistic transactional lock on the database for writing.
+      # Use with {YARD.parse} to ensure the database is not written multiple
+      # times.
+      #
+      # @see #locked_for_writing?
+      def lock_for_writing
+        File.open!(processing_path, 'w') {}
+        yield
+      ensure
+        File.unlink(processing_path) if File.exist?(processing_path)
+      end
+
+      # @return [Boolean] whether the database is currently locked for writing
+      def locked_for_writing?
+        File.exist?(processing_path)
+      end
+
+      def serialized_path(object)
+        path =
+          case object
+          when String, Symbol
+            object = object.to_s
+            if object =~ /#/
+              object += '_i'
+            elsif object =~ /\./
+              object += '_c'
+            end
+            object.split(/::|\.|#/).map do |p|
+              p.gsub(/[^\w\.-]/) do |x|
+                encoded = '_'
+
+                x.each_byte {|b| encoded << ("%X" % b) }
+                encoded
+              end
+            end.join('/') + '.' + extension
+          when YARD::CodeObjects::RootObject
+            'root.dat'
+          else
+            super(object)
+          end
+
+        File.join('objects', path)
+      end
+
+      def serialize(object)
+        if Hash === object
+          super(object[:root], dump(object)) if object[:root]
+        else
+          super(object, dump(object))
+        end
+      end
+
+      def deserialize(path, is_path = false)
+        path = File.join(basepath, serialized_path(path)) unless is_path
+        if File.file?(path)
+          log.debug "Deserializing #{path}..."
+          Marshal.load(File.read_binary(path))
+        else
+          log.debug "Could not find #{path}"
+          nil
+        end
+      end
+
+      private
+
+      def dump(object)
+        object = internal_dump(object, true) unless object.is_a?(Hash)
+        Marshal.dump(object)
+      end
+
+      def internal_dump(object, first_object = false)
+        if !first_object && object.is_a?(CodeObjects::Base) &&
+           !(Tags::OverloadTag === object)
+          return StubProxy.new(object.path)
+        end
+
+        if object.is_a?(Hash) || object.is_a?(Array) ||
+           object.is_a?(CodeObjects::Base) ||
+           !object.instance_variables.empty?
+          object = object.dup
+        end
+
+        object.instance_variables.each do |ivar|
+          ivar_obj = object.instance_variable_get(ivar)
+          ivar_obj_dump = internal_dump(ivar_obj)
+          object.instance_variable_set(ivar, ivar_obj_dump)
+        end
+
+        case object
+        when Hash
+          list = object.map do |k, v|
+            [k, v].map {|item| internal_dump(item) }
+          end
+          object.replace(Hash[list])
+        when Array
+          list = object.map {|item| internal_dump(item) }
+          object.replace(list)
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/yard/server.rb

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-module YARD
-  module Server
-    # Registers a static path to be used in static asset lookup.
-    # @param [String] path the pathname to register
-    # @return [void]
-    # @since 0.6.2
-    def self.register_static_path(path)
-      static_paths = Commands::StaticFileCommand::STATIC_PATHS
-      static_paths.push(path) unless static_paths.include?(path)
-    end
-  end
-end
+# frozen_string_literal: true
+module YARD
+  module Server
+    # Registers a static path to be used in static asset lookup.
+    # @param [String] path the pathname to register
+    # @return [void]
+    # @since 0.6.2
+    def self.register_static_path(path)
+      static_paths = Commands::StaticFileCommand::STATIC_PATHS
+      static_paths.push(path) unless static_paths.include?(path)
+    end
+  end
+end