etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/lib/yard/templates/template_options.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-
-module YARD
-  module Templates
-    # An Options class containing default options for base template rendering. For
-    # options specific to generation of HTML output, see {CLI::YardocOptions}.
-    #
-    # @see CLI::YardocOptions
-    class TemplateOptions < YARD::Options
-      # @return [Symbol] the template output format
-      default_attr :format, :text
-
-      # @return [Symbol] the template name used to render output
-      default_attr :template, :default
-
-      # @return [Symbol] the markup format to use when parsing docstrings
-      default_attr :markup, :rdoc # default is :rdoc but falls back on :none
-
-      # @return [String] the default return type for a method with no return tags
-      default_attr :default_return, "Object"
-
-      # @return [Boolean] whether void methods should show "void" in their signature
-      default_attr :hide_void_return, false
-
-      # @return [Boolean] whether code blocks should be syntax highlighted
-      default_attr :highlight, true
-
-      # @return [Class] the markup provider class for the markup format
-      attr_accessor :markup_provider
-
-      # @return [OpenStruct] an open struct containing any global state across all
-      #   generated objects in a template.
-      default_attr :globals, lambda { OpenStruct.new }
-      alias __globals globals
-
-      # @return [CodeObjects::Base] the main object being generated in the template
-      attr_accessor :object
-
-      # @return [CodeObjects::Base] the owner of the generated object
-      attr_accessor :owner
-
-      # @return [Symbol] the template type used to generate output
-      attr_accessor :type
-
-      # @return [Boolean] whether serialization should be performed
-      default_attr :serialize, true
-
-      # @return [Serializers::Base] the serializer used to generate links and serialize
-      #   output. Serialization output only occurs if {#serialize} is +true+.
-      attr_accessor :serializer
-
-      # @deprecated use {#highlight} instead.
-      # @return [Boolean] whether highlighting should be ignored
-      attr_reader :no_highlight
-      undef no_highlight
-      def no_highlight; !highlight end
-      def no_highlight=(value) self.highlight = !value end
-
-      # @return [String] the title of a given page
-      attr_accessor :page_title
-
-      # @return [Boolean] whether the page is the "index"
-      attr_accessor :index
-
-      # @example A list of mixin path names (including wildcards)
-      #   opts.embed_mixins #=> ['ClassMethods', '*Helper', 'YARD::*']
-      # @return [Array<String>] an array of module name wildcards to embed into
-      #   class documentation as if their methods were defined directly in the class.
-      #   Useful for modules like ClassMethods. If the name contains '::', the module
-      #   is matched against the full mixin path, otherwise only the module name is used.
-      default_attr :embed_mixins, lambda { [] }
-
-      # @param [CodeObjects::Base] mixin accepts any code object, but returns
-      #   nil unless the object is a module.
-      # @return [Boolean] whether a mixin matches the embed_mixins list
-      # @return [nil] if the mixin is not a module object
-      def embed_mixins_match?(mixin)
-        return true if mixin == object # the method is not inherited
-        return nil unless mixin.is_a?(CodeObjects::ModuleObject)
-        embed_mixins.any? do |embed_mixin|
-          re = /\A#{Regexp.quote(embed_mixin).gsub('\*', '.*')}\Z/
-          matchstr = embed_mixin.include?("::") ? mixin.path : mixin.name
-          re.match(matchstr.to_s)
-        end
-      end
-
-      # @return [Verifier] the verifier object
-      attr_accessor :verifier
-    end
-  end
-end

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

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  # Similar to a Proc, but runs a set of Ruby expressions using a small
-  # DSL to make tag lookups easier.
-  #
-  # The syntax is as follows:
-  # * All syntax is Ruby compatible
-  # * +object+ (+o+ for short) exist to access the object being verified
-  # * +@TAGNAME+ is translated into +object.tag('TAGNAME')+
-  # * +@@TAGNAME+ is translated into +object.tags('TAGNAME')+
-  # * +object+ can be omitted as target for method calls (it is implied)
-  #
-  # @example Create a verifier to check for objects that don't have @private tags
-  #   verifier = Verifier.new('!@private')
-  #   verifier.call(object) # => true (no @private tag)
-  # @example Create a verifier to find any return tag with an empty description
-  #   Verifier.new('@return.text.empty?')
-  #   # Equivalent to:
-  #   Verifier.new('object.tag(:return).text.empty?')
-  # @example Check if there are any @param tags
-  #   Verifier.new('@@param.empty?')
-  #   # Equivalent to:
-  #   Verifier.new('object.tags(:param).empty?')
-  # @example Using +object+ or +o+ to look up object attributes directly
-  #   Verifier.new('object.docstring == "hello world"')
-  #   # Equivalent to:
-  #   Verifier.new('o.docstring == "hello world"')
-  # @example Without using +object+ or +o+
-  #   Verifier.new('tag(:return).size == 1 || has_tag?(:author)')
-  # @example Specifying multiple expressions
-  #   Verifier.new('@return', '@param', '@yield')
-  #   # Equivalent to:
-  #   Verifier.new('@return && @param && @yield')
-  class Verifier
-    # @return [Array<String>] a list of all expressions the verifier checks for
-    # @since 0.5.6
-    attr_reader :expressions
-
-    def expressions=(value)
-      @expressions = value
-      create_method_from_expressions
-    end
-
-    # Creates a verifier from a set of expressions
-    #
-    # @param [Array<String>] expressions a list of Ruby expressions to
-    #   parse.
-    def initialize(*expressions)
-      @expressions = []
-      add_expressions(*expressions)
-    end
-
-    # Adds a set of expressions and recompiles the verifier
-    #
-    # @param [Array<String>] expressions a list of expressions
-    # @return [void]
-    # @since 0.5.6
-    def add_expressions(*expressions)
-      self.expressions += expressions.flatten
-    end
-
-    # Passes any method calls to the object from the {#call}
-    def method_missing(sym, *args, &block)
-      if object.respond_to?(sym)
-        object.send(sym, *args, &block)
-      else
-        super
-      end
-    end
-
-    # Tests the expressions on the object.
-    #
-    # @note If the object is a {CodeObjects::Proxy} the result will always be true.
-    # @param [CodeObjects::Base] object the object to verify
-    # @return [Boolean] the result of the expressions
-    def call(object)
-      return true if object.is_a?(CodeObjects::Proxy)
-      modify_nilclass
-      @object = object
-      retval = __execute ? true : false
-      unmodify_nilclass
-      retval
-    end
-
-    # Runs a list of objects against the verifier and returns the subset
-    # of verified objects.
-    #
-    # @param [Array<CodeObjects::Base>] list a list of code objects
-    # @return [Array<CodeObjects::Base>] a list of code objects that match
-    #   the verifier.
-    def run(list)
-      list.reject {|item| call(item).is_a?(FalseClass) }
-    end
-
-    protected
-
-    # @return [CodeObjects::Base] the current object being tested
-    attr_reader :object
-    alias o object
-
-    private
-
-    # @private
-    NILCLASS_METHODS = [:type, :method_missing]
-
-    # Modifies nil to not throw NoMethodErrors. This allows
-    # syntax like object.tag(:return).text to work if the #tag
-    # call returns nil, which means users don't need to perform
-    # stringent nil checking
-    #
-    # @return [void]
-    def modify_nilclass
-      NILCLASS_METHODS.each do |meth|
-        NilClass.send(:define_method, meth) {|*args| }
-      end
-    end
-
-    # Returns the state of NilClass back to normal
-    # @return [void]
-    def unmodify_nilclass
-      NILCLASS_METHODS.each do |meth|
-        next unless nil.respond_to?(meth)
-        NilClass.send(:remove_method, meth)
-      end
-    end
-
-    # Creates the +__execute+ method by evaluating the expressions
-    # as Ruby code
-    # @return [void]
-    def create_method_from_expressions
-      expr = expressions.map {|e| "(#{parse_expression(e)})" }.join(" && ")
-
-      instance_eval(<<-eof, __FILE__, __LINE__ + 1)
-        begin; undef __execute; rescue NameError; end
-        def __execute; #{expr}; end
-      eof
-    end
-
-    # Parses a single expression, handling some of the DSL syntax.
-    #
-    # The syntax "@tag" should be turned into object.tag(:tag),
-    # and "@@tag" should be turned into object.tags(:tag)
-    #
-    # @return [String] the parsed expression
-    def parse_expression(expr)
-      expr = expr.gsub(/@@(?:(\w+)|\{([\w\.]+)\})/, 'object.tags("\1\2")')
-      expr = expr.gsub(/@(?:(\w+)|\{([\w\.]+)\})/, 'object.tag("\1\2")')
-      expr
-    end
-  end
-end

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

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-module YARD
-  VERSION = '0.9.8'
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/cli/command_parser_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::CLI::CommandParser do
-  describe "#run" do
-    before do
-      @cmd = CLI::CommandParser.new
-    end
-
-    it "shows help if --help is provided" do
-      command = double(:command)
-      expect(command).to receive(:run).with('--help')
-      CLI::CommandParser.commands[:foo] = command
-      @cmd.class.default_command = :foo
-      @cmd.run(*%w(foo --help))
-    end
-
-    it "uses default command if first argument is a switch" do
-      command = double(:command)
-      expect(command).to receive(:run).with('--a', 'b', 'c')
-      CLI::CommandParser.commands[:foo] = command
-      @cmd.class.default_command = :foo
-      @cmd.run(*%w(--a b c))
-    end
-
-    it "uses default command if no arguments are provided" do
-      command = double(:command)
-      expect(command).to receive(:run)
-      CLI::CommandParser.commands[:foo] = command
-      @cmd.class.default_command = :foo
-      @cmd.run
-    end
-
-    it "lists commands if command is not found" do
-      expect(@cmd).to receive(:list_commands)
-      @cmd.run(*%w(unknown_command --args))
-    end
-
-    it "lists commands if --help is provided as sole argument" do
-      expect(@cmd).to receive(:list_commands)
-      @cmd.run(*%w(--help))
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/cli/command_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-require 'optparse'
-
-RSpec.describe YARD::CLI::Command do
-  describe "#parse_options" do
-    before do
-      @options = OptionParser.new
-      @saw_foo = false
-      @options.on('--foo') { @saw_foo = true }
-    end
-
-    def parse(*args)
-      CLI::Command.new.send(:parse_options, @options, args)
-      args
-    end
-
-    it "skips unrecognized options but continue to next option" do
-      expect(log).to receive(:warn).with(/Unrecognized.*--list/)
-      expect(log).to receive(:warn).with(/Unrecognized.*--list2/)
-      parse('--list', '--list2', '--foo')
-      expect(@saw_foo).to be true
-    end
-
-    it "skips unrecognized options and any extra non-option arg that follows" do
-      expect(log).to receive(:warn).with(/Unrecognized.*--list/)
-      parse('--list', 'foo', '--foo')
-      expect(@saw_foo).to be true
-    end
-
-    it "stops retrying to parse at non-switch argument" do
-      expect(log).to receive(:warn).with(/Unrecognized.*--list/)
-      args = parse('--list', 'foo', 'foo', 'foo')
-      expect(args).to eq %w(foo foo)
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/cli/config_spec.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-require 'yaml'
-
-RSpec.describe YARD::CLI::Config do
-  before do
-    @config = YARD::CLI::Config.new
-    YARD::Config.options = YARD::Config::DEFAULT_CONFIG_OPTIONS.dup
-    allow(YARD::Config).to receive(:save)
-  end
-
-  def run(*args)
-    @config.run(*args)
-  end
-
-  describe "Listing configuration" do
-    it "accepts --list" do
-      opts = YARD::Config.options
-      expect(YAML).to receive(:dump).twice.and_return("--- foo\nbar\nbaz")
-      expect(log).to receive(:puts).twice.with("bar\nbaz")
-      run
-      run('--list')
-      expect(YARD::Config.options).to eq opts
-    end
-  end
-
-  describe "Viewing an item" do
-    it "views item if no value is given" do
-      YARD::Config.options[:foo] = 'bar'
-      expect(log).to receive(:puts).with('"bar"')
-      run 'foo'
-      expect(YARD::Config.options[:foo]).to eq 'bar'
-    end
-  end
-
-  describe "Modifying an item" do
-    it "accepts --reset to set value" do
-      YARD::Config.options[:load_plugins] = 'foo'
-      run('--reset', 'load_plugins')
-      expect(YARD::Config.options[:load_plugins]).to be false
-    end
-
-    it "accepts --as-list to force single item as list" do
-      run('--as-list', 'foo', 'bar')
-      expect(YARD::Config.options[:foo]).to eq ['bar']
-    end
-
-    it "accepts --append to append values to existing key" do
-      YARD::Config.options[:foo] = ['bar']
-      run('--append', 'foo', 'baz', 'quux')
-      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz', 'quux']
-      run('-a', 'foo', 'last')
-      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz', 'quux', 'last']
-    end
-
-    it "turns key into list if --append is used on single item" do
-      YARD::Config.options[:foo] = 'bar'
-      run('-a', 'foo', 'baz')
-      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz']
-    end
-
-    it "modifies item if value is given" do
-      run('foo', 'xxx')
-      expect(YARD::Config.options[:foo]).to eq 'xxx'
-    end
-
-    it "turns list of values into array of values" do
-      run('foo', 'a', 'b', '1', 'true', 'false')
-      expect(YARD::Config.options[:foo]).to eq ['a', 'b', 1, true, false]
-    end
-
-    it "turns number into numeric Ruby type" do
-      run('foo', '1')
-      expect(YARD::Config.options[:foo]).to eq 1
-    end
-
-    it "turns true into TrueClass" do
-      run('foo', 'true')
-      expect(YARD::Config.options[:foo]).to be true
-    end
-
-    it "turns false into FalseClass" do
-      run('foo', 'false')
-      expect(YARD::Config.options[:foo]).to be false
-    end
-
-    it "saves on modification" do
-      expect(YARD::Config).to receive(:save)
-      run('foo', 'true')
-    end
-  end
-
-  describe "RubyGems hooks" do
-    require 'rubygems'
-
-    class FakeGemConfig < Hash
-      attr_accessor :written
-      def write; @written = true end
-      def path; nil end
-    end
-
-    before do
-      allow(Gem).to receive(:configuration).and_return(FakeGemConfig.new)
-    end
-
-    it "accepts --gem-install-yri" do
-      @config.send(:optparse, '--gem-install-yri')
-      expect(@config.gem_install_cmd).to eq 'yri'
-    end
-
-    it "accepts --gem-install-yard" do
-      @config.send(:optparse, '--gem-install-yard')
-      expect(@config.gem_install_cmd).to eq 'yard'
-    end
-
-    it "does not change back to yri if yard was specified" do
-      @config.send(:optparse, '--gem-install-yard', '--gem-install-yri')
-      expect(@config.gem_install_cmd).to eq 'yard'
-    end
-
-    it "ignores actual config options" do
-      run('--gem-install-yri', 'foo', 'true')
-      expect(YARD::Config).not_to receive(:save)
-    end
-
-    it "updates configuration as :gem if no configuration exists" do
-      run('--gem-install-yri')
-      expect(Gem.configuration[:gem]).to eq "--document=yri"
-      expect(Gem.configuration.written).to eq true
-    end
-
-    [:install, "install", :gem, "gem"].each do |type|
-      it "finds existing config in #{type.inspect} and updates that line without changing anything else" do
-        Gem.configuration[type] = "--opts x"
-        run('--gem-install-yri')
-        expect(Gem.configuration[type]).to eq "--opts x --document=yri"
-        ([:install, "install", :gem, "gem"] - [type]).each do |other|
-          expect(Gem.configuration[other]).to eq nil
-        end
-      end
-    end
-
-    it "scrubs --document values from existing config" do
-      Gem.configuration["gem"] = "--document=yri,ri --no-document --opts x"
-      run('--gem-install-yri')
-      expect(Gem.configuration["gem"]).to eq "--opts x --document=yri"
-    end
-  end
-end