etude_for_ruby 0.1.0 → 0.1.4

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/array_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe Array do
+  describe "#place" do
+    it "creates an Insertion object" do
+      expect([].place('x')).to be_kind_of(Insertion)
+    end
+
+    it "allows multiple objects to be placed" do
+      expect([1, 2].place('x', 'y', 'z').before(2)).to eq [1, 'x', 'y', 'z', 2]
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/file_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+RSpec.describe File do
+  describe ".relative_path" do
+    it "returns the relative path between two files" do
+      expect(File.relative_path('a/b/c/d.html', 'a/b/d/q.html')).to eq '../d/q.html'
+    end
+
+    it "returns the relative path between two directories" do
+      expect(File.relative_path('a/b/c/d/', 'a/b/d/')).to eq '../d'
+    end
+
+    it "returns only the to file if from file is in the same directory as the to file" do
+      expect(File.relative_path('a/b/c/d', 'a/b/c/e')).to eq 'e'
+    end
+
+    it "handles non-normalized paths" do
+      expect(File.relative_path('Hello/./I/Am/Fred', 'Hello/Fred')).to eq '../../Fred'
+      expect(File.relative_path('A//B/C', 'Q/X')).to eq '../../Q/X'
+    end
+  end
+
+  describe ".cleanpath" do
+    it "cleans double brackets" do
+      expect(File.cleanpath('A//B/C')).to eq "A/B/C"
+    end
+
+    it "cleans a path with ." do
+      expect(File.cleanpath('Hello/./I/.Am/Fred')).to eq "Hello/I/.Am/Fred"
+    end
+
+    it "cleans a path with .." do
+      expect(File.cleanpath('Hello/../World')).to eq "World"
+    end
+
+    it "cleans a path with multiple .." do
+      expect(File.cleanpath('A/B/C/../../D')).to eq "A/D"
+    end
+
+    it "cleans a path ending in .." do
+      expect(File.cleanpath('A/B/C/D/..')).to eq "A/B/C"
+    end
+
+    it "passes the initial directory" do
+      expect(File.cleanpath('C/../../D')).to eq "../D"
+    end
+
+    it "does not remove multiple '../' at the beginning" do
+      expect(File.cleanpath('../../A/B')).to eq '../../A/B'
+    end
+  end
+
+  describe ".open!" do
+    it "creates the path before opening" do
+      expect(File).to receive(:directory?).with('/path/to').and_return(false)
+      expect(FileUtils).to receive(:mkdir_p).with('/path/to')
+      expect(File).to receive(:open).with('/path/to/file', 'w')
+      File.open!('/path/to/file', 'w')
+    end
+
+    it "just opens the file if the path exists" do
+      expect(File).to receive(:directory?).with('/path/to').and_return(true)
+      expect(FileUtils).not_to receive(:mkdir_p)
+      expect(File).to receive(:open).with('/path/to/file', 'w')
+      File.open!('/path/to/file', 'w')
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/hash_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe Hash do
+  describe ".[]" do
+    it "accepts an Array argument (Ruby 1.8.6 and older)" do
+      list = [['foo', 'bar'], ['foo2', 'bar2']]
+      expect(Hash[list]).to eq('foo' => 'bar', 'foo2' => 'bar2')
+    end
+
+    it "accepts an array as a key" do
+      expect(Hash[['a', 'b'], 1]).to eq(['a', 'b'] => 1)
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/insertion_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Insertion do
+  describe "#before" do
+    it "places an object before another" do
+      expect([1, 2].place(3).before(2)).to eq [1, 3, 2]
+      expect([1, 2].place(3).before(1)).to eq [3, 1, 2]
+      expect([1, [4], 2].place(3).before(2)).to eq [1, [4], 3, 2]
+    end
+  end
+
+  describe "#after" do
+    it "places an object after another" do
+      expect([1, 2].place(3).after(2)).to eq [1, 2, 3]
+    end
+
+    it "no longer places an object after another and its subsections (0.6)" do
+      expect([1, [2]].place(3).after(1)).to eq [1, 3, [2]]
+    end
+
+    it "places an array after an object" do
+      expect([1, 2, 3].place([4]).after(1)).to eq [1, [4], 2, 3]
+    end
+  end
+
+  describe "#before_any" do
+    it "places an object before another anywhere inside list (including sublists)" do
+      expect([1, 2, [3]].place(4).before_any(3)).to eq [1, 2, [4, 3]]
+    end
+  end
+
+  describe "#after_any" do
+    it "places an object after another anywhere inside list (including sublists)" do
+      expect([1, 2, [3]].place(4).after_any(3)).to eq [1, 2, [3, 4]]
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/module_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Module do
+  describe "#class_name" do
+    it "returns just the name of the class/module" do
+      expect(YARD::CodeObjects::Base.class_name).to eq "Base"
+    end
+  end
+
+  describe "#namespace" do
+    it "returns everything before the class name" do
+      expect(YARD::CodeObjects::Base.namespace_name).to eq "YARD::CodeObjects"
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/string_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# described_in_docs String, '#camelcase'
+# described_in_docs String, '#underscore'
+
+RSpec.describe String do
+  describe "#shell_split" do
+    it "splits simple non-quoted text" do
+      expect("a b c".shell_split).to eq %w(a b c)
+    end
+
+    it "splits double quoted text into single token" do
+      expect('a "b c d" e'.shell_split).to eq ["a", "b c d", "e"]
+    end
+
+    it "splits single quoted text into single token" do
+      expect("a 'b c d' e".shell_split).to eq ["a", "b c d", "e"]
+    end
+
+    it "handles escaped quotations in quotes" do
+      expect("'a \\' b'".shell_split).to eq ["a ' b"]
+    end
+
+    it "handles escaped quotations outside quotes" do
+      expect("\\'a 'b'".shell_split).to eq %w('a b)
+    end
+
+    it "handles escaped backslash" do
+      expect("\\\\'a b c'".shell_split).to eq ['\a b c']
+    end
+
+    it "handles any whitespace as space" do
+      text = "foo\tbar\nbaz\r\nfoo2 bar2"
+      expect(text.shell_split).to eq %w(foo bar baz foo2 bar2)
+    end
+
+    it "handles complex input" do
+      text = "hello \\\"world \"1 2\\\" 3\" a 'b \"\\\\\\'' c"
+      expect(text.shell_split).to eq ["hello", "\"world", "1 2\" 3", "a", "b \"\\'", "c"]
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/yard-0.9.8/spec/core_ext/symbol_hash_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe SymbolHash do
+  it "allows access to keys as String or Symbol" do
+    h = SymbolHash.new(false)
+    h['test'] = true
+    expect(h[:test]).to be true
+    expect(h['test']).to be true
+  end
+
+  describe "#delete" do
+    it "accepts either Strings or Symbols as deletion key" do
+      h = SymbolHash.new
+      expect(h.keys.length).to eq 0
+
+      h['test'] = true
+      expect(h.keys.length).to eq 1
+
+      h.delete(:test)
+      expect(h.keys.length).to eq 0
+
+      h[:test] = true
+      expect(h.keys.length).to eq 1
+
+      h.delete('test')
+      expect(h.keys.length).to eq 0
+    end
+  end
+
+  describe "#key?" do
+    it "returns same result for String or Symbol" do
+      h = SymbolHash.new
+      h[:test] = 1
+      expect(h.key?(:test)).to be true
+      expect(h.has_key?('test')).to be true # rubocop:disable Style/PreferredHashMethods
+    end
+  end
+
+  it "symbolizes value if it is a String (and only a string)" do
+    class Substring < String; end
+
+    h = SymbolHash.new
+    h['test1'] = "hello"
+    h['test2'] = Substring.new("hello")
+    expect(h['test1']).to eq :hello
+    expect(h['test2']).to eq "hello"
+  end
+
+  it "does not symbolize value if SymbolHash.new(false) is created" do
+    h = SymbolHash.new(false)
+    h['test'] = "hello"
+    expect(h[:test]).to eq "hello"
+  end
+
+  it "does not symbolize value if it is not a String" do
+    h = SymbolHash.new
+    h['test'] = [1, 2, 3]
+    expect(h['test']).to eq [1, 2, 3]
+  end
+
+  it "supports symbolization using #update or #merge!" do
+    h = SymbolHash.new
+    h.update('test' => 'value')
+    expect(h[:test]).to eq :value
+    h.merge!('test' => 'value2') # rubocop:disable Performance/RedundantMerge
+    expect(h[:test]).to eq :value2
+  end
+
+  it "supports symbolization non-destructively using #merge" do
+    h = SymbolHash.new
+    expect(h.merge('test' => 'value')[:test]).to eq :value
+    expect(h).to eq SymbolHash.new
+  end
+
+  it "supports #initializing of a hash" do
+    h = SymbolHash[:test => 1]
+    expect(h[:test]).to eq 1
+    expect(h[:somethingelse]).to be nil
+  end
+
+  it "supports reverse merge syntax" do
+    opts = {}
+    opts = SymbolHash[
+      'default' => 1
+    ].update(opts)
+    expect(opts.keys).to eq [:default]
+    expect(opts[:default]).to eq 1
+  end
+end

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

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+RSpec.describe YARD::DocstringParser do
+  after(:all) do
+    YARD::Registry.clear
+  end
+
+  def parse(content, object = nil, handler = nil)
+    @library ||= Tags::Library.instance
+    @parser = DocstringParser.new(@library)
+    @parser.parse(content, object, handler)
+    @parser
+  end
+
+  def docstring(content, object = nil, handler = nil)
+    parse(content, object, handler).to_docstring
+  end
+
+  describe "#parse" do
+    it "parses comments into tags" do
+      doc = docstring(<<-eof)
+@param name Hello world
+  how are you?
+@param name2
+  this is a new line
+@param name3 and this
+  is a new paragraph:
+
+  right here.
+      eof
+      tags = doc.tags(:param)
+      expect(tags[0].name).to eq "name"
+      expect(tags[0].text).to eq "Hello world\nhow are you?"
+      expect(tags[1].name).to eq "name2"
+      expect(tags[1].text).to eq "this is a new line"
+      expect(tags[2].name).to eq "name3"
+      expect(tags[2].text).to eq "and this\nis a new paragraph:\n\nright here."
+    end
+
+    it "ends parsing a tag on de-dent" do
+      doc = docstring(<<-eof)
+@note test
+  one two three
+rest of docstring
+      eof
+      expect(doc.tag(:note).text).to eq "test\none two three"
+      expect(doc).to eq "rest of docstring"
+    end
+
+    it "parses examples embedded in doc" do
+      doc = docstring(<<-eof)
+test string here
+@example code
+
+  def foo(x, y, z)
+  end
+
+  class A; end
+
+more stuff
+eof
+      expect(doc).to eq "test string here\nmore stuff"
+      expect(doc.tag(:example).text).to eq "\ndef foo(x, y, z)\nend\n\nclass A; end"
+    end
+
+    it "removes only original indentation from beginning of line in tags" do
+      doc = docstring(<<-eof)
+@param name
+  some value
+  foo bar
+   baz
+eof
+      expect(doc.tag(:param).text).to eq "some value\nfoo bar\n baz"
+    end
+
+    it "allows numbers in tags" do
+      Tags::Library.define_tag(nil, :foo1)
+      Tags::Library.define_tag(nil, :foo2)
+      Tags::Library.define_tag(nil, :foo3)
+      doc = docstring(<<-eof)
+@foo1 bar1
+@foo2 bar2
+@foo3 bar3
+eof
+      expect(doc.tag(:foo1).text).to eq "bar1"
+      expect(doc.tag(:foo2).text).to eq "bar2"
+    end
+
+    it "ends tag on newline if next line is not indented" do
+      doc = docstring(<<-eof)
+@author bar1
+@api bar2
+Hello world
+eof
+      expect(doc.tag(:author).text).to eq "bar1"
+      expect(doc.tag(:api).text).to eq "bar2"
+    end
+
+    it "warns about unknown tag" do
+      expect(log).to receive(:warn).with(/Unknown tag @hello$/)
+      docstring("@hello world")
+    end
+
+    it "does not add trailing whitespace to freeform tags" do
+      doc = docstring("@api private   \t   ")
+      expect(doc.tag(:api).text).to eq "private"
+    end
+  end
+
+  describe "#parse with custom tag library" do
+    class TestLibrary < Tags::Library; end
+
+    before { @library = TestLibrary.new }
+
+    it "accepts valid tags" do
+      valid = %w(testing valid is_a is_A __)
+      valid.each do |tag|
+        TestLibrary.define_tag("Tag", tag)
+        doc = docstring('@' + tag + ' foo bar')
+        expect(doc.tag(tag).text).to eq 'foo bar'
+      end
+    end
+
+    it "does not parse invalid tag names" do
+      invalid = %w(@ @return@ @p,aram @x-y @.x.y.z)
+      invalid.each do |tag|
+        expect(docstring(tag + ' foo bar')).to eq tag + ' foo bar'
+      end
+    end
+
+    it "allows namespaced tags in the form @x.y.z" do
+      TestLibrary.define_tag("Tag", 'x.y.z')
+      doc = docstring("@x.y.z foo bar")
+      expect(doc.tag('x.y.z').text).to eq 'foo bar'
+    end
+
+    it "ignores new directives without @! prefix syntax" do
+      TestLibrary.define_directive('dir1', Tags::ScopeDirective)
+      expect(log).to receive(:warn).with(/@dir1/)
+      docstring("@dir1")
+    end
+
+    %w(attribute endgroup group macro method scope visibility).each do |tag|
+      it "handles non prefixed @#{tag} syntax as directive, not tag" do
+        TestLibrary.define_directive(tag, Tags::ScopeDirective)
+        parse("@#{tag}")
+        expect(@parser.directives.first).to be_a(Tags::ScopeDirective)
+      end
+    end
+
+    it "handles directives with @! prefix syntax" do
+      TestLibrary.define_directive('dir2', Tags::ScopeDirective)
+      docstring("@!dir2 class")
+      expect(@parser.state.scope).to eq :class
+    end
+  end
+
+  describe "#text" do
+    it "only returns text data" do
+      parse("Foo\n@param foo x y z\nBar")
+      expect(@parser.text).to eq "Foo\nBar"
+    end
+  end
+
+  describe "#raw_text" do
+    it "returns the entire original data" do
+      data = "Foo\n@param foo x y z\nBar"
+      parse(data)
+      expect(@parser.raw_text).to eq data
+    end
+  end
+
+  describe "#tags" do
+    it "returns the parsed tags" do
+      data = "Foo\n@param foo x y z\nBar"
+      parse(data)
+      expect(@parser.tags.size).to eq 1
+      expect(@parser.tags.first.tag_name).to eq 'param'
+    end
+  end
+
+  describe "#directives" do
+    it "groups all processed directives" do
+      data = "Foo\n@!scope class\n@!visibility private\nBar"
+      parse(data)
+      dirs = @parser.directives
+      expect(dirs[0]).to be_a(Tags::ScopeDirective)
+      expect(dirs[0].tag.text).to eq 'class'
+      expect(dirs[1]).to be_a(Tags::VisibilityDirective)
+      expect(dirs[1].tag.text).to eq 'private'
+    end
+  end
+
+  describe "#state" do
+    it "handles modified state" do
+      parse("@!scope class")
+      expect(@parser.state.scope).to eq :class
+    end
+  end
+
+  describe "after_parse (param)" do
+    it "allows specifying of callbacks" do
+      parser = DocstringParser.new
+      the_yielded_obj = nil
+      DocstringParser.after_parse {|obj| the_yielded_obj = obj }
+      parser.parse("Some text")
+      expect(the_yielded_obj).to eq parser
+    end
+
+    it "warns about invalid named parameters" do
+      expect(log).to receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
+      YARD.parse_string <<-eof
+        # @param notaparam foo
+        def foo(a) end
+      eof
+    end
+
+    it "warns about invalid named parameters on @!method directives" do
+      expect(log).to receive(:warn).with(/@param tag has unknown parameter name: notaparam/)
+      YARD.parse_string <<-eof
+        # @!method foo(a)
+        #   @param notaparam foo
+        test
+      eof
+    end
+
+    it "warns about duplicate named parameters" do
+      expect(log).to receive(:warn).with(/@param tag has duplicate parameter name: a/)
+      YARD.parse_string <<-eof
+        # @param a foo
+        # @param a foo
+        def foo(a) end
+      eof
+    end
+
+    it "does not warn on aliases" do
+      expect(log).to_not receive(:warn)
+      YARD.parse_string <<-eof
+        # @param a foo
+        def foo(a) end
+        alias bar foo
+      eof
+    end
+  end
+
+  describe "after_parse (see)" do
+    it "does not warn on valid see tag" do
+      expect(log).to_not receive(:warn)
+      YARD.parse_string "# @see valid\nclass Foo;end"
+    end
+
+    it "warns if {} wraps single name" do
+      expect(log).to receive(:warn).with(/@see tag \(#1\) should not be wrapped in \{\}/)
+      YARD.parse_string "# @see {invalid}\nclass Foo;end"
+    end
+
+    it "warns if {} wraps across name and text" do
+      expect(log).to receive(:warn).with(/@see tag \(#1\) should not be wrapped in \{\}/)
+      YARD.parse_string "# @see {invalid tag}\nclass Foo;end"
+    end
+  end
+end