unparser 0.4.3 → 0.4.8

data/spec/unit/unparser/diff_spec.rb

@@ -0,0 +1,189 @@
+# 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/validation_spec.rb

@@ -0,0 +1,327 @@
+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