unparser 0.4.8 → 0.5.3

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

data/spec/unit/unparser/emitter/class_methods/handle_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Emitter, '.handle', mutant_expression: 'Unparser::Emitter*' do
-  subject { class_under_test.class_eval { handle :foo } }
-
-  let(:class_under_test) do
-    Class.new(described_class)
-  end
-
-  before do
-    stub_const('Unparser::Emitter::REGISTRY', {})
-  end
-
-  it 'should register emitter' do
-    expect { subject }.to change { Unparser::Emitter::REGISTRY }.from({}).to(foo: class_under_test)
-  end
-end

data/spec/unit/unparser/validation_spec.rb

@@ -1,327 +0,0 @@
-require 'spec_helper'
-
-describe Unparser::Validation do
-  let(:object) do
-    described_class.new(
-      identification:   identification,
-      generated_node:   generated_node,
-      generated_source: generated_source,
-      original_node:    original_node,
-      original_source:  original_source
-    )
-  end
-
-  def right(value)
-    MPrelude::Either::Right.new(value)
-  end
-
-  def left(value)
-    MPrelude::Either::Left.new(value)
-  end
-
-  let(:generated_node)   { right(s(:send, s(:int, 1), :foo)) }
-  let(:generated_source) { right('1.foo')                    }
-  let(:identification)   { 'example-identification'          }
-  let(:original_node)    { right(s(:send, s(:int, 1), :foo)) }
-  let(:original_source)  { right('1.foo')                    }
-
-  let(:exception) do
-    left(
-      instance_double(
-        RuntimeError,
-        message: 'foo',
-        backtrace: Array.new(21, &'line-%02d'.method(:%))
-      )
-    )
-  end
-
-  let(:exception_report) do
-    <<~'REPORT'.strip
-      #<InstanceDouble(RuntimeError) (anonymous)>
-      line-00
-      line-01
-      line-02
-      line-03
-      line-04
-      line-05
-      line-06
-      line-07
-      line-08
-      line-09
-      line-10
-      line-11
-      line-12
-      line-13
-      line-14
-      line-15
-      line-16
-      line-17
-      line-18
-      line-19
-    REPORT
-  end
-
-  def report
-    object.report
-  end
-
-  shared_examples 'not successful' do
-    it 'is not successful' do
-      expect(object.success?).to be(false)
-    end
-  end
-
-  context 'on success' do
-    it 'is successful' do
-      expect(object.success?).to be(true)
-    end
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~'REPORT'.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to generate original source with exception' do
-    let(:original_source) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        #{exception_report}
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to parse generated source due precondition error' do
-    let(:generated_node) { left(nil) }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        undefined
-      REPORT
-    end
-  end
-
-  context 'on failing to parse original source' do
-    let(:original_node) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        #{exception_report}
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to generate generated source' do
-    let(:generated_source) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        #{exception_report}
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :foo)
-      REPORT
-    end
-  end
-
-  context 'on failing to parse generated source' do
-    let(:generated_node) { exception }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      expect(report).to eql(<<~REPORT.strip)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        #{exception_report}
-      REPORT
-    end
-  end
-
-  context 'on generating different node' do
-    let(:generated_node) { right(s(:send, s(:int, 1), :bar)) }
-
-    include_examples 'not successful'
-
-    it 'returns expected report' do
-      diff = [
-        Unparser::Color::NONE.format(" (send\n"),
-        Unparser::Color::RED.format("-  (int 1) :foo)\n"),
-        Unparser::Color::GREEN.format("+  (int 1) :bar)\n")
-      ]
-
-      expect(report).to eql(<<~'REPORT' + diff.join)
-        example-identification
-        Original-Source:
-        1.foo
-        Generated-Source:
-        1.foo
-        Original-Node:
-        (send
-          (int 1) :foo)
-        Generated-Node:
-        (send
-          (int 1) :bar)
-        Node-Diff:
-        @@ -1,3 +1,3 @@
-      REPORT
-    end
-  end
-
-  describe '.from_path' do
-    def apply
-      described_class.from_path(path)
-    end
-
-    let(:path)   { instance_double(Pathname, read: source, to_s: '/some/file') }
-    let(:source) { 'true'                                                      }
-
-    it 'returns expected validator' do
-      expect(apply).to eql(
-        described_class.new(
-          generated_node:   right(s(:true)),
-          generated_source: right(source),
-          identification:   '/some/file',
-          original_node:    right(s(:true)),
-          original_source:  right(source)
-        )
-      )
-    end
-  end
-
-  describe '.from_string' do
-    def apply
-      described_class.from_string(source)
-    end
-
-    let(:attributes) do
-      {
-        generated_node:   right(s(:true)),
-        generated_source: right(source),
-        identification:   '(string)',
-        original_node:    right(s(:true)),
-        original_source:  right(source)
-      }
-    end
-
-    context 'on valid original source' do
-      let(:source) { 'true' }
-
-      it 'returns expected validator' do
-        expect(apply).to eql(described_class.new(attributes))
-      end
-
-      context 'with unparsing error' do
-        let(:exception) { RuntimeError.new('example-error') }
-
-        before do
-          allow(Unparser).to receive(:unparse).and_raise(exception)
-        end
-
-        it 'returns expected validator' do
-          validator = apply
-
-          expect(validator.generated_node).to eql(left(nil))
-          expect(validator.generated_source.from_left.class).to be(RuntimeError)
-          expect(validator.original_source).to eql(right(source))
-          expect(validator.original_node).to eql(right(s(:true)))
-        end
-      end
-    end
-
-    # These are actually specifying the wrong behavior as the normalization is a conceptual mistake
-    # But for now we specify them to get this PR through.
-    #
-    # Removal in followup.
-    context 'on denormalized valid original source' do
-      let(:source) { '(true)' }
-
-      it 'returns expected validator' do
-        expect(apply).to eql(described_class.new(attributes.merge(generated_source: right('true'))))
-      end
-    end
-
-    context 'on very denormalized valid original source' do
-      let(:source) { '((true))' }
-
-      it 'returns expected validator' do
-        expect(apply).to eql(described_class.new(attributes.merge(generated_source: right('true'))))
-      end
-    end
-
-    context 'on invalid original source' do
-      let(:source) { '(' }
-
-      it 'returns expected validator' do
-        validator = apply
-
-        expect(validator.generated_node).to eql(left(nil))
-        expect(validator.generated_source).to eql(left(nil))
-        expect(validator.original_source).to eql(right(source))
-        expect(validator.original_node.from_left.class).to be(Parser::SyntaxError)
-      end
-    end
-  end
-end