unparser 0.4.7 → 0.4.8

data/spec/integration/unparser/corpus_spec.rb

@@ -81,26 +81,40 @@ describe 'Unparser on ruby corpus', mutant: false do
       end
     end
 
-    LOADER = Morpher.build do
-      s(:block,
-        s(:guard, s(:primitive, Array)),
-        s(:map,
-          s(:block,
-            s(:guard, s(:primitive, Hash)),
-            s(:hash_transform,
-              s(:key_symbolize, :repo_uri, s(:guard, s(:primitive, String))),
-              s(:key_symbolize, :repo_ref, s(:guard, s(:primitive, String))),
-              s(:key_symbolize, :name,     s(:guard, s(:primitive, String))),
-              s(:key_symbolize, :exclude,  s(:map, s(:guard, s(:primitive, String))))),
-            s(:load_attribute_hash,
-              # NOTE: The domain param has no DSL currently!
-              Morpher::Evaluator::Transformer::Domain::Param.new(
-                Project,
-                [:repo_uri, :repo_ref, :name, :exclude]
-              )))))
-    end
+    transform    = Mutant::Transform
+    string       = transform::Primitive.new(String)
+    string_array = transform::Array.new(string)
+    path         = ROOT.join('spec', 'integrations.yml')
+
+    loader =
+      transform::Named.new(
+        path.to_s,
+        transform::Sequence.new(
+          [
+            transform::Exception.new(SystemCallError, :read.to_proc),
+            transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
+            transform::Array.new(
+              transform::Sequence.new(
+                [
+                  transform::Hash.new(
+                     optional: [],
+                     required: [
+                       transform::Hash::Key.new('exclude',  string_array),
+                       transform::Hash::Key.new('name',     string),
+                       transform::Hash::Key.new('repo_ref', string),
+                       transform::Hash::Key.new('repo_uri', string)
+                    ]
+                  ),
+                  transform::Hash::Symbolize.new,
+                  transform::Exception.new(Anima::Error, Project.public_method(:new))
+                ]
+              )
+            )
+          ]
+        )
+      )
 
-    ALL = LOADER.call(YAML.load_file(ROOT.join('spec', 'integrations.yml')))
+    ALL = loader.apply(path).lmap(&:compact_message).from_right
   end
 
   Project::ALL.each do |project|

data/spec/integrations.yml

@@ -18,7 +18,7 @@
 - name: rubyspec
   repo_uri: 'https://github.com/ruby/spec.git'
   # Revision of rubyspec on the last CI build of unparser that passed
-  repo_ref: 'origin/master'
+  repo_ref: 'b40189b88'
   exclude:
     - command_line/fixtures/bad_syntax.rb
     - core/array/pack/shared/float.rb

data/spec/spec_helper.rb

@@ -1,12 +1,34 @@
-require 'yaml'
+require 'anima'
+require 'mutant'
 require 'pathname'
+require 'timeout'
 require 'unparser'
-require 'anima'
-require 'morpher'
-require 'devtools/spec_helper'
+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)

data/spec/unit/unparser/color_spec.rb

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