kinetic_sdk 5.0.18 → 5.0.20

data/gems/yard-0.9.25/lib/yard/serializers/base.rb

@@ -0,0 +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

data/gems/yard-0.9.25/lib/yard/serializers/file_system_serializer.rb

@@ -0,0 +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

data/gems/yard-0.9.25/lib/yard/serializers/process_serializer.rb

@@ -0,0 +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

data/gems/yard-0.9.25/lib/yard/serializers/stdout_serializer.rb

@@ -0,0 +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

data/gems/yard-0.9.25/lib/yard/serializers/yardoc_serializer.rb

@@ -0,0 +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

data/gems/yard-0.9.25/lib/yard/server/adapter.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module YARD
+  module Server
+    # Short circuits a request by raising an error. This exception is caught
+    # by {Commands::Base#call} to immediately end a request and return a response.
+    class FinishRequest < RuntimeError; end
+
+    # Raises an error if a resource is not found. This exception is caught by
+    # {Commands::Base#call} to immediately end a request and return a 404 response
+    # code. If a message is provided, the body is set to the exception message.
+    class NotFoundError < RuntimeError; end
+
+    # This class implements the bridge between the {Router} and the server
+    # backend for a specific server type. YARD implements concrete adapters
+    # for WEBrick and Rack respectively, though other adapters can be made
+    # for other server architectures.
+    #
+    # == Subclassing Notes
+    # To create a concrete adapter class, implement the {#start} method to
+    # initiate the server backend.
+    #
+    # @abstract
+    class Adapter
+      # @return [String] the location where static files are located, if any.
+      #   To set this field on initialization, pass +:DocumentRoot+ to the
+      #   +server_opts+ argument in {#initialize}
+      attr_accessor :document_root
+
+      # @return [Hash{String=>Array<LibraryVersion>}] a map of libraries.
+      # @see LibraryVersion LibraryVersion for information on building a list of libraries
+      # @see #add_library
+      attr_accessor :libraries
+
+      # @return [Hash] options passed and processed by adapters. The actual
+      #   options mostly depend on the adapters themselves.
+      attr_accessor :options
+
+      # @return [Hash] a set of options to pass to the server backend. Note
+      #   that +:DocumentRoot+ also sets the {#document_root}.
+      attr_accessor :server_options
+
+      # @return [Router] the router object used to route URLs to commands
+      attr_accessor :router
+
+      # Performs any global initialization for the adapter.
+      # @note If you subclass this method, make sure to call +super+.
+      # @return [void]
+      def self.setup
+        Templates::Template.extra_includes |= [YARD::Server::DocServerHelper]
+        Templates::Engine.template_paths |= [File.dirname(__FILE__) + '/templates']
+      end
+
+      # Performs any global shutdown procedures for the adapter.
+      # @note If you subclass this method, make sure to call +super+.
+      # @return [void]
+      def self.shutdown
+        Templates::Template.extra_includes -= [YARD::Server::DocServerHelper]
+        Templates::Engine.template_paths -= [File.dirname(__FILE__) + '/templates']
+      end
+
+      # Creates a new adapter object
+      #
+      # @param [Hash{String=>Array<LibraryVersion>}] libs a list of libraries,
+      #   see {#libraries} for formulating this list.
+      # @param [Hash] opts extra options to pass to the adapter
+      # @option opts [Class] :router (Router) the router class to initialize as the
+      #   adapter's router.
+      # @option opts [Boolean] :caching (false) whether or not caching is enabled
+      # @option opts [Boolean] :single_library (false) whether to server documentation
+      #   for a single or multiple libraries (changes URL structure)
+      def initialize(libs, opts = {}, server_opts = {})
+        self.class.setup
+        self.libraries = libs
+        self.options = opts
+        self.server_options = server_opts
+        self.document_root = server_options[:DocumentRoot]
+        self.router = (options[:router] || Router).new(self)
+        options[:adapter] = self
+        log.debug "Serving libraries using #{self.class}: #{libraries.keys.join(', ')}"
+        log.debug "Caching on" if options[:caching]
+        log.debug "Document root: #{document_root}" if document_root
+      end
+
+      # Adds a library to the {#libraries} mapping for a given library object.
+      # @example Adding a new library to an adapter
+      #   adapter.add_library LibraryVersion.new('mylib', '1.0', '/path/to/.yardoc')
+      # @param [LibraryVersion] library a library to add
+      def add_library(library)
+        libraries[library.name] ||= []
+        libraries[library.name] |= [library]
+      end
+
+      # Implement this method to connect your adapter to your server.
+      # @abstract
+      def start
+        raise NotImplementedError
+      end
+    end
+  end
+end