unparser 0.4.8 → 0.4.9

data/spec/spec_helper.rb

@@ -1,42 +0,0 @@
-require 'anima'
-require 'mutant'
-require 'pathname'
-require 'timeout'
-require 'unparser'
-require 'yaml'
-
-require 'parser/current'
-
-RSpec.configuration.around(file_path: %r{spec/unit}) do |example|
-  Timeout.timeout(0.1, &example)
-end
-
-RSpec.shared_examples_for 'a command method' do
-  it 'returns self' do
-    should equal(object)
-  end
-end
-
-RSpec.shared_examples_for 'an idempotent method' do
-  it 'is idempotent' do
-    first = subject
-    fail 'RSpec not configured for threadsafety' unless RSpec.configuration.threadsafe?
-    mutex    = __memoized.instance_variable_get(:@mutex)
-    memoized = __memoized.instance_variable_get(:@memoized)
-
-    mutex.synchronize { memoized.delete(:subject) }
-    should equal(first)
-  end
-end
-
-module SpecHelper
-  def s(type, *children)
-    Parser::AST::Node.new(type, children)
-  end
-end
-
-RSpec.configure do |config|
-  config.include(SpecHelper)
-  config.extend(SpecHelper)
-  config.raise_errors_for_deprecations!
-end

data/spec/unit/unparser/buffer/append_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#append' do
-  subject { object.append(string) }
-
-  let(:object) { described_class.new }
-  let(:string) { 'foo' }
-
-  specify do
-    expect { subject }.to change { object.content }.from('').to('foo')
-  end
-
-  # Yeah duplicate, mutant will be improved ;)
-  it 'should prefix with indentation if line is empty' do
-    object.append('foo')
-    object.nl
-    object.indent
-    object.append('bar')
-    object.append('baz')
-    expect(object.content).to eql("foo\n  barbaz")
-  end
-
-  it_should_behave_like 'a command method'
-end

data/spec/unit/unparser/buffer/append_without_prefix_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#append_without_prefix' do
-  subject { object.append_without_prefix(string) }
-
-  let(:object) { described_class.new }
-  let(:string) { 'foo' }
-
-  specify do
-    expect { subject }.to change { object.content }.from('').to('foo')
-  end
-
-  it 'should not prefix with indentation' do
-    object.append_without_prefix('foo')
-    object.nl
-    object.indent
-    object.append_without_prefix('bar')
-    object.append_without_prefix('baz')
-    expect(object.content).to eql("foo\nbarbaz")
-  end
-
-  it_should_behave_like 'a command method'
-end

data/spec/unit/unparser/buffer/capture_content_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#capture_content' do
-
-  let(:object) { described_class.new }
-
-  it 'should capture only the content appended within the block' do
-    object.append('foo')
-    object.nl
-    object.indent
-    captured = object.capture_content do
-      object.append('bar')
-      object.nl
-    end
-    expect(captured).to eql("  bar\n")
-  end
-end

data/spec/unit/unparser/buffer/content_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#content' do
-  subject { object.content }
-
-  let(:object) { described_class.new }
-
-  shared_examples_for 'buffer content' do
-    it 'contains expected content' do
-      should eql(expected_content)
-    end
-
-    it { should be_frozen }
-
-    it 'returns fresh string copies' do
-      first  = object.content
-      second = object.content
-      expect(first).to eql(second)
-      expect(first).not_to be(second)
-    end
-  end
-
-  context 'with empty buffer' do
-    let(:expected_content) { '' }
-
-    it_should_behave_like 'buffer content'
-  end
-
-  context 'with filled buffer' do
-    before do
-      object.append('foo')
-    end
-
-    let(:expected_content) { 'foo' }
-
-    it_behaves_like 'buffer content'
-  end
-end

data/spec/unit/unparser/buffer/fresh_line_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#fresh_line?' do
-  let(:object) { described_class.new }
-
-  it 'should return true while buffer is empty' do
-    expect(object.fresh_line?).to eql(true)
-  end
-
-  it 'should return false after content has been appended' do
-    object.append('foo')
-    expect(object.fresh_line?).to eql(false)
-  end
-
-  it 'should return true after a nl has been appended' do
-    object.append('foo')
-    object.nl
-    expect(object.fresh_line?).to eql(true)
-  end
-end

data/spec/unit/unparser/buffer/indent_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#indent' do
-  let(:object) { described_class.new }
-
-  subject { object.indent }
-
-  it 'should indent with two spaces' do
-    object.append('foo')
-    object.nl
-    object.indent
-    object.append('bar')
-    object.nl
-    object.indent
-    object.append('baz')
-    expect(object.content).to eql("foo\n  bar\n    baz")
-  end
-
-  it_should_behave_like 'a command method'
-end

data/spec/unit/unparser/buffer/nl_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#nl' do
-  let(:object) { described_class.new }
-
-  subject { object.nl }
-
-  it 'writes a newline' do
-    object.append('foo')
-    subject
-    object.append('bar')
-    expect(object.content).to eql("foo\nbar")
-  end
-
-  it_should_behave_like 'a command method'
-end

data/spec/unit/unparser/buffer/unindent_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Buffer, '#unindent' do
-  let(:object) { described_class.new }
-
-  subject { object.unindent }
-
-  it 'unindents two chars' do
-    object.append('foo')
-    object.nl
-    object.indent
-    object.append('bar')
-    object.nl
-    object.unindent
-    object.append('baz')
-    expect(object.content).to eql("foo\n  bar\nbaz")
-  end
-
-  it_should_behave_like 'a command method'
-end

data/spec/unit/unparser/color_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Color do
-  shared_examples 'actual color' do |code|
-    describe '#format' do
-
-      it 'returns formatted string' do
-        expect(apply).to eql("\e[#{code}mexample-string\e[0m")
-      end
-    end
-  end
-
-  describe '#format' do
-    let(:input) { 'example-string' }
-
-    def apply
-      object.format(input)
-    end
-
-    context 'RED' do
-      let(:object) { described_class::RED }
-
-      include_examples 'actual color', 31
-    end
-
-    context 'GREEN' do
-      let(:object) { described_class::GREEN }
-
-      include_examples 'actual color', 32
-    end
-
-    context 'NONE' do
-      let(:object) { described_class::NONE }
-
-      it 'returns original input' do
-        expect(apply).to be(input)
-      end
-    end
-  end
-end

data/spec/unit/unparser/comments/consume_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Comments, '#consume' do
-
-  let(:ast_and_comments) do
-    Unparser.parse_with_comments(<<~'RUBY')
-      def hi # EOL 1
-      end # EOL 2
-    RUBY
-  end
-  let(:ast)      { ast_and_comments[0] }
-  let(:comments) { ast_and_comments[1] }
-  let(:object)   { described_class.new(comments) }
-
-  it 'should cause further EOL comments to be returned' do
-    expect(object.take_eol_comments).to eql([])
-    object.consume(ast, :name)
-    expect(object.take_eol_comments).to eql([comments[0]])
-    object.consume(ast, :end)
-    expect(object.take_eol_comments).to eql([comments[1]])
-  end
-end

data/spec/unit/unparser/comments/take_all_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Comments, '#take_all' do
-
-  let(:ast_and_comments) do
-    Unparser.parse_with_comments(<<~'RUBY')
-      def hi # EOL 1
-      end # EOL 2
-    RUBY
-  end
-  let(:ast)      { ast_and_comments[0] }
-  let(:comments) { ast_and_comments[1] }
-  let(:object)   { described_class.new(comments) }
-
-  it 'should take all comments' do
-    expect(object.take_all).to eql(comments)
-    expect(object.take_all).to eql([])
-  end
-end

data/spec/unit/unparser/comments/take_before_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Comments, '#take_before' do
-
-  let(:ast)      { ast_and_comments[0] }
-  let(:comments) { ast_and_comments[1] }
-  let(:object)   { described_class.new(comments) }
-
-  context 'usual case' do
-
-    let(:ast_and_comments) do
-      Unparser.parse_with_comments(<<~'RUBY')
-        def hi # EOL 1
-          # comment
-        end # EOL 2
-      RUBY
-    end
-
-    it 'should return no comments if none are before the node' do
-      expect(object.take_before(ast, :expression)).to eql([])
-    end
-
-    it 'should return only the comments that are before the specified part of the node' do
-      expect(object.take_before(ast, :end)).to eql(comments.first(2))
-      expect(object.take_all).to eql([comments[2]])
-    end
-  end
-
-  context 'when node does not respond to source part' do
-
-    let(:ast_and_comments) do
-      Unparser.parse_with_comments(<<~'RUBY')
-        expression ? :foo : :bar # EOL 1
-        # EOL 2
-      RUBY
-    end
-
-    it 'should return no comments if none are before the node' do
-      expect(object.take_before(ast, :expression)).to eql([])
-    end
-
-    it 'should return only the comments that are before the specified part of the node' do
-      expect(object.take_before(ast, :end)).to eql([])
-    end
-  end
-end

data/spec/unit/unparser/comments/take_eol_comments_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Comments, '#take_eol_comments' do
-
-  let(:ast_and_comments) do
-    Unparser.parse_with_comments(<<~'RUBY')
-      def hi # EOL 1
-      =begin
-      doc comment
-      =end
-      end # EOL 2
-    RUBY
-  end
-  let(:ast)              { ast_and_comments[0] }
-  let(:comments)         { ast_and_comments[1] }
-  let(:object)           { described_class.new(comments) }
-
-  it 'should return no comments if nothing has been consumed' do
-    expect(object.take_eol_comments).to eql([])
-  end
-
-  it 'should return comments once their line has been consumed' do
-    object.consume(ast, :name)
-    expect(object.take_eol_comments).to eql([comments[0]])
-  end
-
-  it 'should leave doc comments to be taken later' do
-    object.consume(ast)
-    expect(object.take_eol_comments).to eql([comments[0], comments[2]])
-    expect(object.take_all).to eql([comments[1]])
-  end
-end

data/spec/unit/unparser/diff_spec.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Unparser::Diff do
-  let(:object) { described_class }
-
-  describe '.build' do
-
-    subject { object.build(old_string, new_string) }
-
-    let(:old_string) { "foo\nbar" }
-    let(:new_string) { "bar\nbaz" }
-
-    it { should eql(described_class.new(%w[foo bar], %w[bar baz])) }
-
-  end
-
-  describe '#colorized_diff' do
-    let(:object) { described_class.new(old, new) }
-
-    subject { object.colorized_diff }
-
-    context 'when there is a diff at begin of hunk' do
-      let(:old) { %w[foo bar] }
-      let(:new) { %w[baz bar] }
-
-      let(:expectation) do
-        [
-          "@@ -1,3 +1,3 @@\n",
-          Unparser::Color::RED.format("-foo\n"),
-          Unparser::Color::GREEN.format("+baz\n"),
-          " bar\n"
-        ].join
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when there is no diff' do
-      let(:old) { '' }
-      let(:new) { '' }
-
-      it { should be(nil) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-  end
-
-  describe '#diff' do
-    let(:object) { described_class.new(old, new) }
-
-    subject { object.diff }
-
-    context 'when there is a diff at begin and end' do
-      let(:old) { %w[foo bar foo] }
-      let(:new) { %w[baz bar baz] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,4 +1,4 @@
-          -foo
-          +baz
-           bar
-          -foo
-          +baz
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when there is a diff at begin of hunk' do
-      let(:old) { %w[foo bar] }
-      let(:new) { %w[baz bar] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,3 +1,3 @@
-          -foo
-          +baz
-           bar
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when there is a diff NOT at begin of hunk' do
-      let(:old) { %w[foo bar]     }
-      let(:new) { %w[foo baz bar] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,3 +1,4 @@
-           foo
-          +baz
-           bar
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when the diff has a long context at begin' do
-      let(:old) { %w[foo bar baz boz a b c]       }
-      let(:new) { %w[foo bar baz boz a b c other] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,8 +1,9 @@
-           foo
-           bar
-           baz
-           boz
-           a
-           b
-           c
-          +other
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when the diff has a long context at end, deleting' do
-      let(:old) { %w[other foo bar baz boz a b c] }
-      let(:new) { %w[foo bar baz boz a b c]       }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,9 +1,8 @@
-          -other
-           foo
-           bar
-           baz
-           boz
-           a
-           b
-           c
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when the diff has a long context at end, inserting' do
-      let(:old) { %w[foo bar baz boz a b c]       }
-      let(:new) { %w[other foo bar baz boz a b c] }
-
-      let(:expectation) do
-        <<~STR
-          @@ -1,8 +1,9 @@
-          +other
-           foo
-           bar
-           baz
-           boz
-           a
-           b
-           c
-        STR
-      end
-
-      it { should eql(expectation) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-
-    context 'when there is no diff' do
-      let(:old) { '' }
-      let(:new) { '' }
-
-      it { should be(nil) }
-
-      it_should_behave_like 'an idempotent method'
-    end
-  end
-end