etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/lib/yard/rubygems/doc_manager.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-begin
-  require 'rubygems/user_interaction'
-  require 'rubygems/doc_manager'
-rescue LoadError
-  nil # noop
-end
-
-class Gem::DocManager
-  def self.load_yardoc
-    require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. yard)))
-  end
-
-  def run_yardoc(*args)
-    args << '--quiet'
-    args << '--backtrace' if Gem.configuration.backtrace
-    unless File.file?(File.join(@spec.full_gem_path, '.yardopts'))
-      args << @spec.require_paths
-      unless @spec.extra_rdoc_files.empty?
-        args << '-'
-        args += @spec.extra_rdoc_files
-      end
-    end
-    args = args.flatten.map(&:to_s)
-
-    old_pwd = Dir.pwd
-    Dir.chdir(@spec.full_gem_path)
-    YARD::CLI::Yardoc.run(*args)
-  rescue Errno::EACCES => e
-    dirname = File.dirname e.message.split("-")[1].strip
-    raise Gem::FilePermissionError, dirname
-  rescue => ex
-    alert_error "While generating documentation for #{@spec.full_name}"
-    ui.errs.puts "... MESSAGE:   #{ex}"
-    ui.errs.puts "... YARDOC args: #{args.join(' ')}"
-    ui.errs.puts "\t#{ex.backtrace.join("\n\t")}" if Gem.configuration.backtrace
-    ui.errs.puts "(continuing with the rest of the installation)"
-  ensure
-    Dir.chdir(old_pwd)
-  end
-
-  begin undef setup_rdoc; rescue NameError; nil end
-  def setup_rdoc
-    if File.exist?(@doc_dir) && !File.writable?(@doc_dir)
-      raise Gem::FilePermissionError, @doc_dir
-    end
-
-    FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
-
-    self.class.load_rdoc if @spec.has_rdoc?
-    self.class.load_yardoc if @spec.has_yardoc?
-  end
-
-  def install_yardoc
-    rdoc_dir = File.join(@doc_dir, 'rdoc')
-
-    FileUtils.rm_rf rdoc_dir
-
-    say "Installing YARD documentation for #{@spec.full_name}..."
-    run_yardoc '-o', rdoc_dir
-  end
-
-  def install_ri_yard
-    install_ri_yard_orig if @spec.has_rdoc?
-    return if @spec.has_rdoc? == false
-    return if @spec.has_yardoc?
-
-    self.class.load_yardoc
-    say "Building YARD (yri) index for #{@spec.full_name}..."
-    run_yardoc '-c', '-n'
-  end
-
-  begin
-    alias install_ri_yard_orig install_ri
-    alias install_ri install_ri_yard
-  rescue NameError; nil end
-
-  def install_rdoc_yard
-    if @spec.has_rdoc?
-      install_rdoc_yard_orig
-    elsif @spec.has_yardoc?
-      install_yardoc
-    end
-  end
-
-  begin
-    alias install_rdoc_yard_orig install_rdoc
-    alias install_rdoc install_rdoc_yard
-  rescue NameError; nil end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/lib/yard/rubygems/hook.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-require 'rubygems'
-require 'rubygems/user_interaction'
-require 'fileutils'
-
-##
-# Gem::YARDoc provides methods to generate YARDoc and yri data for installed gems
-# upon gem installation.
-#
-# This file is automatically required by RubyGems 1.9 and newer.
-
-module YARD
-  class RubygemsHook
-    include Gem::UserInteraction
-    extend Gem::UserInteraction
-
-    @yard_version = nil
-
-    ##
-    # Force installation of documentation?
-
-    attr_accessor :force
-
-    ##
-    # Generate yard?
-
-    attr_accessor :generate_yard
-
-    ##
-    # Generate yri data?
-
-    attr_accessor :generate_yri
-
-    class << self
-      ##
-      # Loaded version of YARD. Set by ::load_yard
-
-      attr_reader :yard_version
-    end
-
-    ##
-    # Post installs hook that generates documentation for each specification in
-    # +specs+
-
-    def self.generation_hook(installer, specs)
-      start = Time.now
-      types = installer.document
-
-      generate_yard = types.include?('yardoc') || types.include?('yard')
-      generate_yri = types.include? 'yri'
-
-      specs.each do |spec|
-        gen_yard = generate_yard
-        gen_yri = generate_yri
-        gen_yri = false if gen_yard # never generate both, no need
-        unless types.empty? # --no-document is not in effect
-          # look at spec.metadata['yard.run'] for override
-          run_yard = spec.metadata['yard.run']
-          gen_yard = true if run_yard && run_yard != 'yri'
-          gen_yri = true if run_yard == 'yri'
-        end
-
-        new(spec, gen_yard, gen_yri).generate
-      end
-
-      return unless generate_yard || generate_yri
-
-      duration = (Time.now - start).to_i
-      names = specs.map(&:name).join ', '
-
-      say "Done installing documentation for #{names} after #{duration} seconds"
-    end
-
-    ##
-    # Loads the YARD generator
-
-    def self.load_yard
-      return if @yard_version
-
-      require 'yard'
-
-      @yard_version = Gem::Version.new ::YARD::VERSION
-    end
-
-    def initialize(spec, generate_yard = false, generate_yri = true)
-      @doc_dir = spec.doc_dir
-      @force = false
-      @spec = spec
-
-      @generate_yard = generate_yard
-      @generate_yri = generate_yri
-
-      @yard_dir = spec.doc_dir('yard')
-      @yri_dir = spec.doc_dir('.yardoc')
-    end
-
-    def run_yardoc(*args)
-      args << '--quiet' unless Gem.configuration.really_verbose
-      args << '--backtrace' if Gem.configuration.backtrace
-      unless File.file?(File.join(@spec.full_gem_path, '.yardopts'))
-        args << @spec.require_paths
-        unless @spec.extra_rdoc_files.empty?
-          args << '-'
-          args += @spec.extra_rdoc_files
-        end
-      end
-      args = args.flatten.map(&:to_s)
-
-      Dir.chdir(@spec.full_gem_path) do
-        YARD::CLI::Yardoc.run(*args)
-      end
-    rescue Errno::EACCES => e
-      dirname = File.dirname e.message.split("-")[1].strip
-      raise Gem::FilePermissionError, dirname
-    rescue => ex
-      alert_error "While generating documentation for #{@spec.full_name}"
-      ui.errs.puts "... MESSAGE:   #{ex}"
-      ui.errs.puts "... YARDOC args: #{args.join(' ')}"
-      ui.errs.puts "\t#{ex.backtrace.join("\n\t")}" if Gem.configuration.backtrace
-      ui.errs.puts "(continuing with the rest of the installation)"
-    end
-
-    def install_yard
-      FileUtils.rm_rf @yard_dir
-
-      say "Installing YARD documentation for #{@spec.full_name}..."
-      run_yardoc '--no-progress', '--db', @yri_dir, '-o', @yard_dir
-    end
-
-    def install_yri
-      FileUtils.rm_rf @yri_dir
-
-      say "Building YARD (yri) index for #{@spec.full_name}..."
-      run_yardoc '--no-progress', '-c', '-n', '--db', @yri_dir
-    end
-
-    ##
-    # Generates YARD and yri data
-
-    def generate
-      return if @spec.default_gem?
-      return unless @generate_yri || @generate_yard
-
-      setup
-
-      install_yri if @generate_yri && (@force || !File.exist?(@yri_dir))
-
-      install_yard if @generate_yard && (@force || !File.exist?(@yard_dir))
-    end
-
-    ##
-    # Prepares the spec for documentation generation
-
-    def setup
-      self.class.load_yard
-
-      if File.exist?(@doc_dir)
-        raise Gem::FilePermissionError, @doc_dir unless File.writable?(@doc_dir)
-      else
-        FileUtils.mkdir_p @doc_dir
-      end
-    end
-  end
-end
-
-Gem.done_installing(&YARD::RubygemsHook.method(:generation_hook))

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/lib/yard/rubygems/specification.rb

@@ -1,42 +0,0 @@
-# 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
-
-    @@default_value[:has_rdoc] = true if defined?(@@default_value)
-    @@attributes << 'has_rdoc' if defined?(@@attributes)
-    @@nil_attributes << 'has_rdoc' if defined?(@@nil_attributes)
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/lib/yard/serializers/base.rb

@@ -1,83 +0,0 @@
-# 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/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/lib/yard/serializers/file_system_serializer.rb

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