etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/tags/library_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::Library do
-  def tag(docstring)
-    Docstring.new(docstring).tags.first
-  end
-
-  describe "#see_tag" do
-    it "takes a URL" do
-      expect(tag("@see http://example.com").name).to eq "http://example.com"
-    end
-
-    it "takes an object path" do
-      expect(tag("@see String#reverse").name).to eq "String#reverse"
-    end
-
-    it "takes a description after the url/object" do
-      tag = tag("@see http://example.com An Example Site")
-      expect(tag.name).to eq "http://example.com"
-      expect(tag.text).to eq "An Example Site"
-    end
-  end
-
-  describe ".define_tag" do
-    it "allows defining tags with '.' in the name (x.y.z defines method x_y_z)" do
-      Tags::Library.define_tag("foo", 'x.y.z')
-      Tags::Library.define_tag("foo2", 'x.y.zz', Tags::OverloadTag)
-      expect(Tags::Library.instance.method(:x_y_z_tag)).not_to be nil
-      expect(Tags::Library.instance.method(:x_y_zz_tag)).not_to be nil
-      expect(tag('@x.y.z foo bar').text).to eq 'foo bar'
-      expect(tag('@x.y.zz foo(bar)').signature).to eq 'foo(bar)'
-    end
-  end
-
-  describe "#tag.explain_types" do
-    it "can explain tag types" do
-      expect(tag("@return [A, B<String>]").explain_types).to eq "an A; a B of (Strings)"
-    end
-
-    it "returns nil if no types present" do
-      expect(tag("@return").explain_types).to eq nil
-    end
-
-    it "returns nil if types are not parseable" do
-      expect(tag("@return [$]").explain_types).to eq nil
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/tags/overload_tag_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::OverloadTag do
-  before do
-    @tag = Tags::OverloadTag.new(:overload, <<-'eof')
-      def bar(a, b = 1, &block)
-        Hello world
-        @param a [String]
-        @return [String]
-    eof
-  end
-
-  it "parses the first line as a method signature" do
-    expect(@tag.signature).to eq "def bar(a, b = 1, &block)"
-    expect(@tag.parameters).to eq [['a', nil], ['b', "1"], ['&block', nil]]
-  end
-
-  it "parses the rest of the text as a new Docstring" do
-    expect(@tag.docstring).to be_instance_of(Docstring)
-    expect(@tag.docstring).to eq "Hello world"
-  end
-
-  it "sets Docstring's object after #object= is called" do
-    m = double(:object)
-    @tag.object = m
-    expect(@tag.docstring.object).to eq m
-  end
-
-  it "responds to #tag, #tags and #has_tag?" do
-    @tag.object = double(:object)
-    expect(@tag.tags.size).to eq 2
-    expect(@tag.tag(:param).name).to eq "a"
-    expect(@tag.has_tag?(:return)).to be true
-  end
-
-  it "is not a CodeObjects::Base when not hooked up to an object" do
-    @tag.object = nil
-    expect(@tag.is_a?(CodeObjects::Base)).to be false
-  end
-
-  it "is a CodeObjects::Base when hooked up to an object" do
-    @tag.object = double(:object)
-    expect(@tag.object).to receive(:is_a?).at_least(3).times.with(CodeObjects::Base).and_return(true)
-    expect(@tag.is_a?(CodeObjects::Base)).to be true
-    expect(@tag.is_a?(CodeObjects::Base)).to be true
-    expect(CodeObjects::Base === @tag).to be true
-  end
-
-  it "does not parse 'def' out of method name" do
-    tag = Tags::OverloadTag.new(:overload, "default")
-    expect(tag.signature).to eq "default"
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/tags/ref_tag_list_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::RefTagList do
-  before { YARD::Registry.clear }
-
-  it "accepts symbol or string as owner's path and convert it into a proxy" do
-    t = Tags::RefTagList.new('author', :String)
-    expect(t.owner).to eq P(:String)
-  end
-
-  it "accepts proxy object as owner" do
-    t = Tags::RefTagList.new('author', P(:String))
-    expect(t.owner).to eq P(:String)
-  end
-
-  it "returns tags from a proxy object" do
-    o = CodeObjects::ClassObject.new(:root, :String)
-    t = Tags::Tag.new(:author, 'foo')
-    o.docstring.add_tag(t)
-
-    ref = Tags::RefTagList.new('author', :String)
-    expect(ref.tags).to eq [t]
-    expect(ref.tags.first.text).to eq 'foo'
-  end
-
-  it "returns named tags from a proxy object" do
-    o = CodeObjects::ClassObject.new(:root, :String)
-    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
-    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
-    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
-    t1 = Tags::Tag.new(:return, 'blah')
-    o.docstring.add_tag(p1, t1, p2, p3)
-
-    ref = Tags::RefTagList.new('param', :String, 'foo')
-    expect(ref.tags).to eq [p1, p2]
-    expect(ref.tags.first.text).to eq 'bar1'
-  end
-
-  it "all tags should respond to #owner and be a RefTag" do
-    o = CodeObjects::ClassObject.new(:root, :String)
-    p1 = Tags::Tag.new(:param, 'bar1', nil, 'foo')
-    p2 = Tags::Tag.new(:param, 'bar2', nil, 'foo')
-    p3 = Tags::Tag.new(:param, 'bar3', nil, 'bar')
-    t1 = Tags::Tag.new(:return, 'blah')
-    o.docstring.add_tag(p1, t1, p2, p3)
-
-    ref = Tags::RefTagList.new('param', :String)
-    ref.tags.each do |t|
-      expect(t).to be_kind_of(Tags::RefTag)
-      expect(t.owner).to eq o
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/tags/types_explainer_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Tags::TypesExplainer do
-  Type = YARD::Tags::TypesExplainer::Type
-  CollectionType = YARD::Tags::TypesExplainer::CollectionType
-  FixedCollectionType = YARD::Tags::TypesExplainer::FixedCollectionType
-  HashCollectionType = YARD::Tags::TypesExplainer::HashCollectionType
-  Parser = YARD::Tags::TypesExplainer::Parser
-
-  def parse(types)
-    Parser.new(types).parse
-  end
-
-  def parse_fail(types)
-    expect(lambda { parse(types) }).to raise_error(SyntaxError)
-  end
-
-  describe Type, '#to_s' do
-    before { @t = Type.new(nil) }
-
-    it "works for a class/module reference" do
-      @t.name = "ClassModuleName"
-      expect(@t.to_s).to eq "a ClassModuleName"
-      expect(@t.to_s(false)).to eq "ClassModuleNames"
-
-      @t.name = "XYZ"
-      expect(@t.to_s).to eq "a XYZ"
-      expect(@t.to_s(false)).to eq "XYZ's"
-
-      @t.name = "Array"
-      expect(@t.to_s).to eq "an Array"
-      expect(@t.to_s(false)).to eq "Arrays"
-    end
-
-    it "works for a method (ducktype)" do
-      @t.name = "#mymethod"
-      expect(@t.to_s).to eq "an object that responds to #mymethod"
-      expect(@t.to_s(false)).to eq "objects that respond to #mymethod"
-    end
-
-    it "works for a constant value" do
-      ['false', 'true', 'nil', '4'].each do |name|
-        @t.name = name
-        expect(@t.to_s).to eq name
-        expect(@t.to_s(false)).to eq name
-      end
-    end
-  end
-
-  describe CollectionType, '#to_s' do
-    before { @t = CollectionType.new("Array", nil) }
-
-    it "can contain one item" do
-      @t.types = [Type.new("Object")]
-      expect(@t.to_s).to eq "an Array of (Objects)"
-    end
-
-    it "can contain more than one item" do
-      @t.types = [Type.new("Object"), Type.new("String"), Type.new("Symbol")]
-      expect(@t.to_s).to eq "an Array of (Objects, Strings or Symbols)"
-    end
-
-    it "can contain nested collections" do
-      @t.types = [CollectionType.new("List", [Type.new("Object")])]
-      expect(@t.to_s).to eq "an Array of (a List of (Objects))"
-    end
-  end
-
-  describe FixedCollectionType, '#to_s' do
-    before { @t = FixedCollectionType.new("Array", nil) }
-
-    it "can contain one item" do
-      @t.types = [Type.new("Object")]
-      expect(@t.to_s).to eq "an Array containing (an Object)"
-    end
-
-    it "can contain more than one item" do
-      @t.types = [Type.new("Object"), Type.new("String"), Type.new("Symbol")]
-      expect(@t.to_s).to eq "an Array containing (an Object followed by a String followed by a Symbol)"
-    end
-
-    it "can contain nested collections" do
-      @t.types = [FixedCollectionType.new("List", [Type.new("Object")])]
-      expect(@t.to_s).to eq "an Array containing (a List containing (an Object))"
-    end
-  end
-
-  describe FixedCollectionType, '#to_s' do
-    before { @t = HashCollectionType.new("Hash", nil, nil) }
-
-    it "can contain a single key type and value type" do
-      @t.key_types = [Type.new("Object")]
-      @t.value_types = [Type.new("Object")]
-      expect(@t.to_s).to eq "a Hash with keys made of (Objects) and values of (Objects)"
-    end
-
-    it "can contain multiple key types" do
-      @t.key_types = [Type.new("Key"), Type.new("String")]
-      @t.value_types = [Type.new("Object")]
-      expect(@t.to_s).to eq "a Hash with keys made of (Keys or Strings) and values of (Objects)"
-    end
-
-    it "can contain multiple value types" do
-      @t.key_types = [Type.new("String")]
-      @t.value_types = [Type.new("true"), Type.new("false")]
-      expect(@t.to_s).to eq "a Hash with keys made of (Strings) and values of (true or false)"
-    end
-  end
-
-  describe Parser, '#parse' do
-    it "parses a regular class name" do
-      type = parse("MyClass")
-      expect(type.size).to eq 1
-      expect(type.first).to be_a(Type)
-      expect(type.first.name).to eq "MyClass"
-    end
-
-    it "parses a path reference name" do
-      type = parse("A::B")
-      expect(type.size).to eq 1
-      expect(type.first).to be_a(Type)
-      expect(type.first.name).to eq "A::B"
-    end
-
-    it "parses a list of simple names" do
-      type = parse("A, B::C, D, E")
-      expect(type.size).to eq 4
-      expect(type[0].name).to eq "A"
-      expect(type[1].name).to eq "B::C"
-      expect(type[2].name).to eq "D"
-      expect(type[3].name).to eq "E"
-    end
-
-    it "parses a collection type" do
-      type = parse("MyList<String>")
-      expect(type.first).to be_a(CollectionType)
-      expect(type.first.types.size).to eq 1
-      expect(type.first.name).to eq "MyList"
-      expect(type.first.types.first.name).to eq "String"
-    end
-
-    it "allows a collection type without a name" do
-      type = parse("<String>")
-      expect(type.first.name).to eq "Array"
-    end
-
-    it "allows a fixed collection type without a name" do
-      type = parse("(String)")
-      expect(type.first.name).to eq "Array"
-    end
-
-    it "allows a hash collection type without a name" do
-      type = parse("{K=>V}")
-      expect(type.first.name).to eq "Hash"
-    end
-
-    it "does not accept two commas in a row" do
-      parse_fail "A,,B"
-    end
-
-    it "does not accept two types not separated by a comma" do
-      parse_fail "A B"
-    end
-
-    it "does not allow a comma without a following type" do
-      parse_fail "A, "
-    end
-
-    it "fails on any unrecognized character" do
-      parse_fail "$"
-    end
-  end
-
-  describe ".explain" do
-    it "parses an arbitrarily nested collection type" do
-      explain = YARD::Tags::TypesExplainer.explain("Array<String, Array<Symbol, List(String, {K=>V})>>")
-      result = "an Array of (Strings or an Array of (Symbols or a List containing
-        (a String followed by a Hash with keys made of (K's) and values of (V's))))"
-      expect(explain).to eq result.delete("\n").squeeze(' ')
-    end
-
-    it "parses various examples" do
-      expect = {
-        "Fixnum, Foo, Object, true" => "a Fixnum; a Foo; an Object; true",
-        "#read" => "an object that responds to #read",
-        "Array<String, Symbol, #read>" => "an Array of (Strings, Symbols or objects that respond to #read)",
-        "Set<Number>" => "a Set of (Numbers)",
-        "Array(String, Symbol)" => "an Array containing (a String followed by a Symbol)",
-        "Hash{String => Symbol, Number}" => "a Hash with keys made of (Strings) and values of (Symbols or Numbers)",
-        "Array<Foo, Bar>, List(String, Symbol, #to_s), {Foo, Bar => Symbol, Number}" => "an Array of (Foos or Bars);
-          a List containing (a String followed by a Symbol followed by an object that responds to #to_s);
-          a Hash with keys made of (Foos or Bars) and values of (Symbols or Numbers)"
-      }
-      expect.each do |input, expected|
-        explain = YARD::Tags::TypesExplainer.explain(input)
-        expect(explain).to eq expected.delete("\n").squeeze(' ')
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/templates/class_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Templates::Engine.template(:default, :docstring) do
-  before do
-    Registry.clear
-    YARD.parse_string <<-'eof'
-      private
-      # Comments
-      # @abstract override this class
-      # @author Test
-      # @version 1.0
-      # @see A
-      # @see http://example.com Example
-      class A < B
-        # HI
-        def method_missing(*args) end
-        # @deprecated
-        def a; end
-
-        # constructor method!
-        def initialize(test) end
-      end
-
-      class C < A; end
-
-      class D
-        # @private
-        def initialize; end
-      end
-    eof
-  end
-
-  it "renders html format correctly" do
-    html_equals(Registry.at('A').format(html_options), :class001)
-  end
-
-  it "renders text format correctly" do
-    text_equals(Registry.at('A').format, :class001)
-  end
-
-  it "hides private constructors" do
-    html_equals(Registry.at('D').format(html_options(:verifier => Verifier.new("!@private"))), :class002)
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/templates/constant_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Templates::Engine.template(:default, :constant) do
-  describe "fully dressed constant" do
-    it "renders text format correctly" do
-      YARD.parse_string <<-'eof'
-        class YARD::CLI::YRI
-          # Default search paths that should be loaded dynamically into YRI. These paths
-          # take precedence over all other paths ({SEARCH_PATHS_FILE} and RubyGems
-          # paths). To add a path, call:
-          #
-          #   DEFAULT_SEARCH_PATHS.push("/path/to/.yardoc")
-          #
-          # @return [Array<String>] a list of extra search paths
-          # @since 0.6.0
-          DEFAULT_SEARCH_PATHS = []
-        end
-      eof
-      text_equals(Registry.at('YARD::CLI::YRI::DEFAULT_SEARCH_PATHS').format(text_options), :constant001)
-    end
-  end
-
-  describe "simple constant with no documentation" do
-    it "renders text format correctly" do
-      # Short constant should show on single line
-      YARD.parse_string <<-'eof'
-        MYCONST = 'foo'
-      eof
-      text_equals(Registry.at('MYCONST').format(text_options), :constant002)
-
-      # Long constant should show on multiple lines, indented
-      YARD.parse_string <<-'eof'
-        MYCONST = [A, B, C, D, E, F, G, H, I, J, K, L,
-          M, N, O, P, Q, R, S, T, U, V, W,
-          X, Y, Z]
-      eof
-      text_equals(Registry.at('MYCONST').format(text_options), :constant003)
-    end
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/templates/engine_spec.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Templates::Engine do
-  before { @paths = Engine.template_paths }
-  after { Engine.template_paths = @paths }
-
-  describe ".register_template_path" do
-    it "registers a String path" do
-      Engine.register_template_path('.')
-      expect(Engine.template_paths.pop).to eq '.'
-    end
-
-    it "does not duplicate paths" do
-      Engine.template_paths = []
-      Engine.register_template_path('foo')
-      Engine.register_template_path('foo')
-      expect(Engine.template_paths).to eq ['foo']
-    end
-  end
-
-  describe ".template!" do
-    it "creates a module including Template" do
-      mod = Engine.template!('path/to/template')
-      expect(mod).to include(Template)
-      expect(mod.full_path.to_s).to eq 'path/to/template'
-    end
-
-    it "creates a module including Template with full_path" do
-      mod = Engine.template!('path/to/template2', '/full/path/to/template2')
-      expect(mod).to include(Template)
-      expect(mod.full_path.to_s).to eq '/full/path/to/template2'
-    end
-  end
-
-  describe ".template" do
-    it "raises an error if the template is not found" do
-      expect { Engine.template(:a, :b, :c) }.to raise_error(ArgumentError)
-    end
-
-    it "creates a module including Template" do
-      mock = double(:template)
-      expect(Engine).to receive(:find_template_paths).with(nil, 'template/name').and_return(['/full/path/template/name'])
-      expect(Engine).to receive(:template!).with('template/name', ['/full/path/template/name']).and_return(mock)
-      expect(Engine.template('template/name')).to eq mock
-    end
-
-    it "creates a Template from a relative Template path" do
-      expect(Engine).to receive(:template_paths).and_return([])
-      expect(File).to receive(:directory?).with("/full/path/template/notname").and_return(true)
-      start_template = double(:start_template,
-        :full_path  => '/full/path/template/name',
-        :full_paths => ['/full/path/template/name'])
-      expect(start_template).to receive(:is_a?).with(Template).and_return(true)
-      mod = Engine.template(start_template, '..', 'notname')
-      expect(mod).to include(Template)
-      expect(mod.full_path.to_s).to eq "/full/path/template/notname"
-    end
-
-    it "creates a Template including other matching templates in path" do
-      paths = ['/full/path/template/name', '/full/path2/template/name']
-      expect(Engine).to receive(:find_template_paths).with(nil, 'template').at_least(1).times.and_return([])
-      expect(Engine).to receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
-      ancestors = Engine.template('template/name').ancestors.map(&:class_name)
-      expect(ancestors).to include("Template__full_path2_template_name")
-    end
-
-    it "includes parent directories before other template paths" do
-      paths = ['/full/path/template/name', '/full/path2/template/name']
-      expect(Engine).to receive(:find_template_paths).with(nil, 'template/name').and_return(paths)
-      ancestors = Engine.template('template/name').ancestors.map(&:class_name)
-      expect(ancestors[0, 4]).to eq ["Template__full_path_template_name", "Template__full_path_template",
-        "Template__full_path2_template_name", "Template__full_path2_template"]
-    end
-  end
-
-  describe ".generate" do
-    it "generates with fulldoc template" do
-      mod = double(:template)
-      options = TemplateOptions.new
-      options.reset_defaults
-      options.objects = [:a, :b, :c]
-      options.object = Registry.root
-      expect(mod).to receive(:run).with(options)
-      expect(Engine).to receive(:template).with(:default, :fulldoc, :text).and_return(mod)
-      Engine.generate([:a, :b, :c])
-    end
-  end
-
-  describe ".render" do
-    def loads_template(*args)
-      expect(Engine).to receive(:template).with(*args).and_return(@template)
-    end
-
-    before(:all) do
-      @object = CodeObjects::MethodObject.new(:root, :method)
-    end
-
-    before do
-      @options = TemplateOptions.new
-      @options.reset_defaults
-      @options.object = @object
-      @options.type = @object.type
-      @template = double(:template, :include => nil)
-      expect(@template).to receive(:run).with(@options)
-    end
-
-    it "accepts method call with no parameters" do
-      loads_template(:default, :method, :text)
-      @object.format
-    end
-
-    it "allows template key to be changed" do
-      loads_template(:javadoc, :method, :text)
-      @options.template = :javadoc
-      @object.format(:template => :javadoc)
-    end
-
-    it "allows type key to be changed" do
-      loads_template(:default, :fulldoc, :text)
-      @options.type = :fulldoc
-      @object.format(:type => :fulldoc)
-    end
-
-    it "allows format key to be changed" do
-      loads_template(:default, :method, :html)
-      @options.format = :html
-      @object.format(:format => :html)
-    end
-  end
-end