etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/handlers/spec_helper.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require 'stringio'
-
-include Handlers
-
-def undoc_error(code)
-  expect { StubbedSourceParser.parse_string(code) }.to raise_error(Parser::UndocumentableError)
-end
-
-def with_parser(parser_type)
-  tmp = StubbedSourceParser.parser_type
-  StubbedSourceParser.parser_type = parser_type
-  yield
-  StubbedSourceParser.parser_type = tmp
-end
-
-class StubbedProcessor < Processor
-  def process(statements)
-    statements.each_with_index do |stmt, _index|
-      find_handlers(stmt).each do |handler|
-        handler.new(self, stmt).process
-      end
-    end
-  end
-end
-
-class StubbedSourceParser < Parser::SourceParser
-  StubbedSourceParser.parser_type = :ruby
-  def post_process
-    post = StubbedProcessor.new(self)
-    post.process(@parser.enumerator)
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/handlers/visibility_handler_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
-  before(:all) { parse_file :visibility_handler_001, __FILE__ }
-
-  it "is able to set visibility to public" do
-    expect(Registry.at("Testing#pub").visibility).to eq :public
-    expect(Registry.at("Testing#pub2").visibility).to eq :public
-  end
-
-  it "is able to set visibility to private" do
-    expect(Registry.at("Testing#priv").visibility).to eq :private
-  end
-
-  it "is able to set visibility to protected" do
-    expect(Registry.at("Testing#prot").visibility).to eq :protected
-  end
-
-  it "supports parameters and only set visibility on those methods" do
-    expect(Registry.at('Testing#notpriv').visibility).to eq :protected
-    expect(Registry.at('Testing#notpriv2').visibility).to eq :protected
-    expect(Registry.at('Testing#notpriv?').visibility).to eq :protected
-  end
-
-  it "only accepts strings and symbols" do
-    expect(Registry.at('Testing#name')).to be nil
-    expect(Registry.at('Testing#argument')).to be nil
-    expect(Registry.at('Testing#method_call')).to be nil
-  end
-
-  it "handles constants passed in as symbols" do
-    expect(Registry.at('Testing#Foo').visibility).to eq :private
-  end
-
-  it "does not register classes with visibility" do
-    expect(Registry.at('Testing::Bar').visibility).to eq :public
-    expect(Registry.at('Testing::Baz').visibility).to eq :public
-  end
-
-  it "can decorate a method definition" do
-    expect(Registry.at('Testing#decpriv').visibility).to eq :private
-  end unless LEGACY_PARSER
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/handlers/yield_handler_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler" do
-  before(:all) { parse_file :yield_handler_001, __FILE__ }
-
-  it "only parses yield blocks in methods" do
-    expect(P(:Testing).tag(:yield)).to be nil
-    expect(P(:Testing).tag(:yieldparam)).to be nil
-  end
-
-  it "handles an empty yield statement" do
-    expect(P('Testing#mymethod').tag(:yield)).to be nil
-    expect(P('Testing#mymethod').tag(:yieldparam)).to be nil
-  end
-
-  it "does not document a yield statement in a method with either @yield or @yieldparam" do
-    expect(P('Testing#mymethod2').tag(:yield).types).to eq ['a', 'b']
-    expect(P('Testing#mymethod2').tag(:yield).text).to eq "Blah"
-    expect(P('Testing#mymethod2').tags(:yieldparam).size).to eq 2
-
-    expect(P('Testing#mymethod3').tag(:yield).types).to eq ['a', 'b']
-    expect(P('Testing#mymethod3').tags(:yieldparam).size).to eq 0
-
-    expect(P('Testing#mymethod4').tag(:yieldparam).name).to eq '_self'
-    expect(P('Testing#mymethod4').tag(:yieldparam).text).to eq 'BLAH'
-  end
-
-  it "handles any arbitrary yield statement" do
-    expect(P('Testing#mymethod5').tag(:yield).types).to eq [':a', 'b', '_self', 'File.read(\'file\', \'w\')', 'CONSTANT']
-  end
-
-  it "handles parentheses" do
-    expect(P('Testing#mymethod6').tag(:yield).types).to eq ['b', 'a']
-  end
-
-  it "only documents the first yield statement in a method (limitation of yield handler)" do
-    expect(P('Testing#mymethod7').tag(:yield).types).to eq ['a']
-  end
-
-  it "handles `self` keyword and list object type as yieldparam for _self" do
-    expect(P('Testing#mymethod8').tag(:yield).types).to eq ['_self']
-    expect(P('Testing#mymethod8').tag(:yieldparam).types).to eq ['Testing']
-    expect(P('Testing#mymethod8').tag(:yieldparam).text).to eq "the object that the method was called on"
-  end
-
-  it "handles `super` keyword and document it under _super" do
-    expect(P('Testing#mymethod9').tag(:yield).types).to eq ['_super']
-    expect(P('Testing#mymethod9').tag(:yieldparam).types).to be nil
-    expect(P('Testing#mymethod9').tag(:yieldparam).text).to eq "the result of the method from the superclass"
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/i18n/locale_spec.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Locale do
-  def locale(name)
-    YARD::I18n::Locale.new(name)
-  end
-
-  before do
-    @locale = locale("fr")
-  end
-
-  describe "#name" do
-    it "returns name" do
-      expect(locale("fr").name).to eq "fr"
-    end
-  end
-
-  describe "#load" do
-    it "returns false for nonexistent PO" do
-      expect(File).to receive(:exist?).with('foo/fr.po').and_return(false)
-      expect(@locale.load('foo')).to be false
-    end
-
-    have_gettext_gem = true
-    if RUBY_VERSION < "1.9"
-      begin
-        require "gettext/tools/poparser"
-      rescue LoadError
-        have_gettext_gem = false
-      end
-    else
-      begin
-        require "gettext/po_parser"
-      rescue LoadError
-        begin
-          require "gettext/tools/poparser"
-        rescue LoadError
-          have_gettext_gem = false
-        end
-      end
-    end
-
-    it "returns true for existent PO", :if => have_gettext_gem do
-      data = <<-eop
-msgid ""
-msgstr ""
-"Language: fr\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-msgid "Hello"
-msgstr "Bonjour"
-eop
-      parser = GetText::POParser.new
-      expect(File).to receive(:exist?).with('foo/fr.po').and_return(true)
-      expect(GetText::POParser).to receive(:new).and_return(parser)
-      expect(parser).to receive(:parse_file) do |file, hash|
-        expect(file).to eq 'foo/fr.po'
-        parser.parse(String.new(data), hash)
-      end
-      expect(@locale.load('foo')).to be true
-      expect(@locale.translate('Hello')).to eq "Bonjour"
-    end
-  end
-
-  describe "#translate" do
-    before do
-      messages = @locale.instance_variable_get(:@messages)
-      messages["Hello"] = "Bonjour"
-    end
-
-    it "returns translated string for existent string" do
-      expect(@locale.translate("Hello")) == "Bonjour"
-    end
-
-    it "returns original string for nonexistent string" do
-      expect(@locale.translate("nonexistent")) == "nonexistent"
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/i18n/message_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Message do
-  def message(id)
-    YARD::I18n::Message.new(id)
-  end
-
-  before do
-    @message = message("Hello World!")
-  end
-
-  describe "#id" do
-    it "returns ID" do
-      expect(message("Hello World!").id).to eq "Hello World!"
-    end
-  end
-
-  describe "#add_location" do
-    it "adds some locations" do
-      @message.add_location("hello.rb", 10)
-      @message.add_location("message.rb", 5)
-      expect(@message.locations).to eq Set.new([["hello.rb", 10], ["message.rb", 5]])
-    end
-  end
-
-  describe "#add_comment" do
-    it "adds some comments" do
-      @message.add_comment("YARD.title")
-      @message.add_comment("Hello#message")
-      expect(@message.comments).to eq Set.new(["YARD.title", "Hello#message"])
-    end
-  end
-
-  describe "#==" do
-    it "returns true for same value messages" do
-      locations = [["hello.rb", 10], ["message.rb", 5]]
-      comments = ["YARD.title", "Hello#message"]
-
-      other_message = message(@message.id)
-      locations.each do |path, line|
-        @message.add_location(path, line)
-        other_message.add_location(path, line)
-      end
-      comments.each do |comment|
-        @message.add_comment(comment)
-        other_message.add_comment(comment)
-      end
-
-      expect(@message).to eq other_message
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/i18n/messages_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Messages do
-  def message(id)
-    YARD::I18n::Message.new(id)
-  end
-
-  def messages
-    YARD::I18n::Messages.new
-  end
-
-  before do
-    @messages = messages
-  end
-
-  describe "#each" do
-    it "enumerates messages" do
-      @messages.register("Hello World!")
-      @messages.register("Title")
-      enumerated_messages = []
-      @messages.each do |message|
-        enumerated_messages << message
-      end
-      enumerated_messages = enumerated_messages.sort_by(&:id)
-      expect(enumerated_messages).to eq [message("Hello World!"), message("Title")]
-    end
-
-    it "does not yield any message if there are none" do
-      enumerated_messages = []
-      @messages.each do |message|
-        enumerated_messages << message
-      end
-      expect(enumerated_messages).to eq []
-    end
-  end
-
-  describe "#[]" do
-    it "returns registered message" do
-      @messages.register("Hello World!")
-      expect(@messages["Hello World!"]).to eq message("Hello World!")
-    end
-
-    it "returns nil for nonexistent message ID" do
-      expect(@messages["Hello World!"]).to eq nil
-    end
-  end
-
-  describe "#register" do
-    it "returns registered message" do
-      expect(@messages.register("Hello World!")).to eq message("Hello World!")
-    end
-
-    it "returns existent message" do
-      message = @messages.register("Hello World!")
-      expect(@messages.register("Hello World!").object_id).to eq message.object_id
-    end
-  end
-
-  describe "#==" do
-    it "returns true for same value messages" do
-      @messages.register("Hello World!")
-      other_messages = messages
-      other_messages.register("Hello World!")
-      expect(@messages).to eq other_messages
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/yard-0.9.8/spec/i18n/pot_generator_spec.rb

@@ -1,295 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::PotGenerator do
-  def create_messages(messages)
-    yard_messages = YARD::I18n::Messages.new
-    add_messages(yard_messages, messages)
-    yard_messages
-  end
-
-  def add_messages(yard_messages, messages)
-    messages.each do |id, properties|
-      yard_message = yard_messages.register(id)
-      (properties[:locations] || []).each do |path, line|
-        yard_message.add_location(path, line)
-      end
-      (properties[:comments] || []).each do |comment|
-        yard_message.add_comment(comment)
-      end
-    end
-  end
-
-  before do
-    @generator = YARD::I18n::PotGenerator.new("..")
-  end
-
-  describe "Generate" do
-    it "generates the default header" do
-      current_time = Time.parse("2011-11-20 22:17+0900")
-      allow(@generator).to receive(:current_time).and_return(current_time)
-      pot_creation_date = current_time.strftime("%Y-%m-%d %H:%M%z")
-      expect(@generator.generate).to eq <<-eoh
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\\n"
-"Report-Msgid-Bugs-To: \\n"
-"POT-Creation-Date: #{pot_creation_date}\\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"Language: \\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=UTF-8\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-
-eoh
-    end
-
-    it "generates messages in location order" do
-      allow(@generator).to receive(:header).and_return("HEADER\n\n")
-      messages = {
-        "tag|see|Parser::SourceParser.parse" => {
-          :locations => [["yard.rb", 14]],
-          :comments => ["@see"]
-        },
-        "Parses a path or set of paths" => {
-          :locations => [["yard.rb", 12], ["yard/parser/source_parser.rb", 83]],
-          :comments => ["YARD.parse", "YARD::Parser::SourceParser.parse"]
-        }
-      }
-      add_messages(@generator.messages, messages)
-      expect(@generator.generate).to eq <<-'eoh'
-HEADER
-
-# YARD.parse
-# YARD::Parser::SourceParser.parse
-#: ../yard.rb:12
-#: ../yard/parser/source_parser.rb:83
-msgid "Parses a path or set of paths"
-msgstr ""
-
-# @see
-#: ../yard.rb:14
-msgid "tag|see|Parser::SourceParser.parse"
-msgstr ""
-
-eoh
-    end
-  end
-
-  describe "Escape" do
-    def generate_message_pot(message_id)
-      pot = String.new("")
-      message = YARD::I18n::Message.new(message_id)
-      @generator.send(:generate_message, pot, message)
-      pot
-    end
-
-    it "escapes <\\>" do
-      expect(generate_message_pot("hello \\ world")).to eq <<-'eop'
-msgid "hello \\ world"
-msgstr ""
-
-eop
-    end
-
-    it "escapes <\">" do
-      expect(generate_message_pot("hello \" world")).to eq <<-'eop'
-msgid "hello \" world"
-msgstr ""
-
-eop
-    end
-
-    it "escapes <\\n>" do
-      expect(generate_message_pot("hello \n world")).to eq <<-'eop'
-msgid "hello \n"
-" world"
-msgstr ""
-
-eop
-    end
-  end
-
-  describe "Object" do
-    before do
-      Registry.clear
-      @yard = YARD::CodeObjects::ModuleObject.new(:root, :YARD)
-    end
-
-    it "extracts at docstring" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = "An alias to {Parser::SourceParser}'s parsing method"
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "An alias to {Parser::SourceParser}'s parsing method" => {
-          :locations => [],
-          :comments => ["YARD.parse"]
-        }
-      )
-    end
-
-    it "extracts at location" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = "An alias to {Parser::SourceParser}'s parsing method"
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "An alias to {Parser::SourceParser}'s parsing method" => {
-          :locations => [["yard.rb", 13]],
-          :comments => ["YARD.parse"]
-        }
-      )
-    end
-
-    it "extracts at tag name" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = "@see Parser::SourceParser.parse"
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|see|Parser::SourceParser.parse" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@see"]
-        }
-      )
-    end
-
-    it "extracts at tag text" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = <<-eod
-@example Parse a glob of files
-  YARD.parse('lib/**/*.rb')
-eod
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|example|Parse a glob of files" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@example"]
-        },
-        "YARD.parse('lib/**/*.rb')" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@example Parse a glob of files"]
-        }
-      )
-    end
-
-    it "extracts at tag types" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = <<-eod
-@param [String, Array<String>] paths a path, glob, or list of paths to
-  parse
-eod
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|param|paths" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@param [String, Array<String>]"]
-        },
-        "a path, glob, or list of paths to\nparse" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@param [String, Array<String>] paths"]
-        }
-      )
-    end
-
-    it "extracts at overload tag recursively" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = <<-eod
-@overload foo(i)
-  docstring foo(i)
-  @param [Integer] i integer parameter
-eod
-      end
-
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|overload|foo" => {
-          :locations => [],
-          :comments => ["@overload"]
-        },
-        "docstring foo(i)" => {
-          :locations => [],
-          :comments => ["YARD.parse"]
-        },
-        "tag|param|i" => {
-          :locations => [],
-          :comments => ["@param [Integer]"]
-        },
-        "integer parameter" => {
-          :locations => [],
-          :comments => ["@param [Integer] i"]
-        }
-      )
-    end
-  end
-
-  describe "File" do
-    it "extracts at attribute" do
-      path = "GettingStarted.md"
-      text = <<-eor
-# @title Getting Started Guide
-
-# Getting Started with YARD
-eor
-      allow(File).to receive(:open).with(path).and_yield(StringIO.new(text))
-      allow(File).to receive(:read).with(path).and_return(text)
-      file = YARD::CodeObjects::ExtraFileObject.new(path)
-      @generator.parse_files([file])
-      expect(@generator.messages).to eq create_messages(
-        "Getting Started Guide" => {
-          :locations => [[path, 1]],
-          :comments => ["title"]
-        },
-        "# Getting Started with YARD" => {
-          :locations => [[path, 3]],
-          :comments => []
-        }
-      )
-    end
-
-    it "extracts at paragraphs" do
-      path = "README.md"
-      paragraph1 = <<-eop.strip
-Note that class methods must not be referred to with the "::" namespace
-separator. Only modules, classes and constants should use "::".
-eop
-      paragraph2 = <<-eop.strip
-You can also do lookups on any installed gems. Just make sure to build the
-.yardoc databases for installed gems with:
-eop
-      text = <<-eot
-#{paragraph1}
-
-#{paragraph2}
-eot
-      allow(File).to receive(:open).with(path).and_yield(StringIO.new(text))
-      allow(File).to receive(:read).with(path).and_return(text)
-      file = YARD::CodeObjects::ExtraFileObject.new(path)
-      @generator.parse_files([file])
-      expect(@generator.messages).to eq create_messages(
-        paragraph1 => {
-          :locations => [[path, 1]],
-          :comments => []
-        },
-        paragraph2 => {
-          :locations => [[path, 4]],
-          :comments => []
-        }
-      )
-    end
-  end
-end