morpher 0.2.6

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'devtools/spec_helper'
+require 'morpher'
+require 'mutant' # for the node helpers
+
+# Monkeypatch to mutant all specs per mutation.
+#
+# TODO: Use master once it supports configurable implicit coverage.
+#
+# Morpher predicates are needed to finally make this configurable in mutant.
+#
+module Mutant
+
+  module Rspec
+    class Killer
+
+      # Return all example groups
+      #
+      # @return [Enumerable<RSpec::Example>]
+      #
+      # @api private
+      #
+      def example_groups
+        strategy.example_groups
+      end
+
+    end # Rspec
+  end # Killer
+end # Mutant
+
+RSpec.configure do |config|
+  config.include(StripHelper)
+  config.include(Morpher::NodeHelpers)
+  config.expect_with :rspec do |rspec|
+    rspec.syntax = %i[expect should]
+  end
+end

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,8 @@
+require 'ice_nine'
+
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/support/let_mock_helper.rb

@@ -0,0 +1,8 @@
+module LetMockHelper
+  def let_mock(name, &block)
+    let(name) do
+      stubs = block ? instance_exec(double, &block) : {}
+      double(name.to_s.capitalize, stubs)
+    end
+  end
+end

data/spec/support/strip_helper.rb

@@ -0,0 +1,12 @@
+module StripHelper
+  def strip(text)
+    return text if text.empty?
+    lines = text.lines
+    match = /\A[ ]*/.match(lines.first)
+    range = match[0].length..-1
+    source = lines.map do |line|
+      line[range]
+    end.join
+    source.chomp << "\n"
+  end
+end

data/spec/unit/morpher/compiler/preprocessor_spec.rb

@@ -0,0 +1,46 @@
+describe Morpher::Compiler::Preprocessor do
+  subject { Morpher::Compiler::Preprocessor::DEFAULT.call(input) }
+
+  shared_examples_for 'a preprocessor' do
+    it { should eql(expected) }
+
+    it 'is able to compile output' do
+      Morpher.compile(subject)
+    end
+  end
+
+  context 'with s(:boolean)' do
+
+    it_should_behave_like 'a preprocessor' do
+      let(:input)    { s(:boolean) }
+      let(:expected) { s(:xor, s(:primitive, TrueClass), s(:primitive, FalseClass)) }
+    end
+
+  end
+
+  class Example
+    include Anima.new(:foo, :bar)
+  end
+
+  let(:param) do
+    Morpher::Evaluator::Transformer::Domain::Param.new(Example, %i[foo bar])
+  end
+
+  context 'with s(:anima_load)' do
+
+    it_should_behave_like 'a preprocessor' do
+      let(:input)    { s(:anima_load, Example) }
+      let(:expected) { s(:load_attribute_hash, param) }
+    end
+
+  end
+
+  context 'with s(:anima_dump)' do
+
+    it_should_behave_like 'a preprocessor' do
+      let(:input)    { s(:anima_dump, Example) }
+      let(:expected) { s(:dump_attribute_hash, param) }
+    end
+
+  end
+end

data/spec/unit/morpher/evaluator/nullary/parameterized_spec.rb

@@ -0,0 +1,25 @@
+describe Morpher::Evaluator::Nullary::Parameterized do
+
+  describe '.include' do
+    let(:object) do
+      Class.new(Morpher::Evaluator) do
+        include Morpher::Evaluator::Nullary::Parameterized
+
+        def self.name
+          'Foo'
+        end
+      end
+    end
+
+    let(:instance) do
+      object.new('foo')
+    end
+
+    it 'sets up printer' do
+      instance.description.should eql(strip(<<-'TEXT'))
+        Foo
+          param: "foo"
+      TEXT
+    end
+  end
+end

data/spec/unit/morpher/evaluator/predicate/boolean/and_spec.rb

@@ -0,0 +1,11 @@
+describe Morpher::Evaluator::Predicate::Boolean::And do
+  let(:object) { described_class.new([body_a, body_b]) }
+
+  let(:body_a) { Morpher.compile(s(:primitive, String))                          }
+  let(:body_b) { Morpher.compile(s(:eql, s(:attribute, :length), s(:static, 1))) }
+
+  let(:negative_input) { ''   }
+  let(:positive_input) { 'a'  }
+
+  include_examples 'predicate evaluator'
+end

data/spec/unit/morpher/evaluator/predicate/boolean/or_spec.rb

@@ -0,0 +1,26 @@
+describe Morpher::Evaluator::Predicate::Boolean::Or do
+  let(:object) { described_class.new([body_a, body_b]) }
+
+  let(:body_a) { Morpher.compile(s(:primitive, String)) }
+  let(:body_b) { Morpher.compile(s(:primitive, Symbol)) }
+
+  let(:negative_input) { Object.new }
+  let(:positive_input) { ''         }
+
+  include_examples 'predicate evaluator'
+
+  context '#evalaution' do
+
+    context 'on positive input' do
+      subject { object.evaluation(positive_input) }
+
+      its(:evaluations) { should eql([body_a.evaluation(positive_input)]) }
+    end
+
+    context 'on negative input' do
+      subject { object.evaluation(negative_input) }
+
+      its(:evaluations) { should eql(object.body.map { |node| node.evaluation(negative_input) }) }
+    end
+  end
+end

data/spec/unit/morpher/evaluator/predicate/boolean/xor_spec.rb

@@ -0,0 +1,26 @@
+describe Morpher::Evaluator::Predicate::Boolean::Xor do
+  let(:object) { described_class.new([body_a, body_b]) }
+
+  let(:body_a) { Morpher.compile(s(:primitive, TrueClass)) }
+  let(:body_b) { Morpher.compile(s(:primitive, FalseClass)) }
+
+  let(:negative_input) { nil  }
+  let(:positive_input) { true }
+
+  include_examples 'predicate evaluator'
+
+  context '#evalaution' do
+
+    context 'on positive input' do
+      subject { object.evaluation(positive_input) }
+
+      its(:evaluations) { should eql([body_a.evaluation(positive_input)]) }
+    end
+
+    context 'on negative input' do
+      subject { object.evaluation(negative_input) }
+
+      its(:evaluations) { should eql(object.body.map { |node| node.evaluation(negative_input) }) }
+    end
+  end
+end

data/spec/unit/morpher/evaluator/predicate/contrandiction_spec.rb

@@ -0,0 +1,7 @@
+describe Morpher::Evaluator::Predicate::Contradiction do
+  let(:object)          { described_class.new }
+  let(:valid_input)     { double('Input')     }
+  let(:expected_output) { false               }
+
+  include_examples 'transforming evaluator on valid input'
+end

data/spec/unit/morpher/evaluator/predicate/eql_spec.rb

@@ -0,0 +1,11 @@
+describe Morpher::Evaluator::Predicate::EQL do
+  let(:object) { described_class.new(left, right) }
+
+  let(:left)  { Morpher.compile(s(:static, 1.0)) }
+  let(:right) { Morpher.compile(s(:input))       }
+
+  let(:positive_input) { 1.0 }
+  let(:negative_input) { 1   }
+
+  include_examples 'predicate evaluator'
+end

data/spec/unit/morpher/evaluator/predicate/negation_spec.rb

@@ -0,0 +1,10 @@
+describe Morpher::Evaluator::Predicate::Negation do
+  let(:object) { described_class.new(operand) }
+
+  let(:operand) { Morpher.compile(s(:input)) }
+
+  let(:positive_input) { false }
+  let(:negative_input) { true  }
+
+  include_examples 'predicate evaluator'
+end

data/spec/unit/morpher/evaluator/predicate/primitive_spec.rb

@@ -0,0 +1,17 @@
+describe Morpher::Evaluator::Predicate::Primitive::Exact do
+  let(:object) { described_class.new(Morpher::Evaluator) }
+
+  let(:positive_input) { Morpher::Evaluator.allocate }
+  let(:negative_input) { Morpher::Evaluator::Predicate.allocate }
+
+  include_examples 'predicate evaluator'
+end
+
+describe Morpher::Evaluator::Predicate::Primitive::Permissive do
+  let(:object) { described_class.new(Morpher::Evaluator) }
+
+  let(:positive_input) { Morpher::Evaluator::Predicate.allocate }
+  let(:negative_input) { '' }
+
+  include_examples 'predicate evaluator'
+end

data/spec/unit/morpher/evaluator/predicate/tautology_spec.rb

@@ -0,0 +1,7 @@
+describe Morpher::Evaluator::Predicate::Tautology do
+  let(:object)          { described_class.new }
+  let(:valid_input)     { double('Input')     }
+  let(:expected_output) { true                }
+
+  include_examples 'transforming evaluator on valid input'
+end

data/spec/unit/morpher/evaluator/transformer/attribute_spec.rb

@@ -0,0 +1,9 @@
+describe Morpher::Evaluator::Transformer::Attribute do
+  let(:object) { described_class.new(:length) }
+
+  include_examples 'transforming evaluator on valid input'
+  include_examples 'intransitive evaluator'
+
+  let(:valid_input)     { 'foo' }
+  let(:expected_output) { 3     }
+end

data/spec/unit/morpher/evaluator/transformer/block_spec.rb

@@ -0,0 +1,92 @@
+describe Morpher::Evaluator::Transformer::Block do
+
+  let(:ast) do
+    s(:block, body_a, body_b)
+  end
+
+  let(:object) do
+    Morpher.compile(ast)
+  end
+
+  let(:evaluator_a) do
+    Morpher.compile(body_a)
+  end
+
+  let(:evaluator_b) do
+    Morpher.compile(body_b)
+  end
+
+  context 'transitive' do
+
+    let(:body_a) do
+      s(:guard, s(:primitive, String))
+    end
+
+    let(:body_b) do
+      s(:guard, s(:primitive, String))
+    end
+
+    let(:valid_input)     { 'foo' }
+    let(:expected_output) { 'foo' }
+    let(:invalid_input)   { :foo  }
+
+    let(:expected_exception) do
+      Morpher::Evaluator::Transformer::TransformError.new(object.body.first, invalid_input)
+    end
+
+    include_examples 'transitive evaluator'
+
+    context 'with invalid input' do
+      specify '#evaluation' do
+        evaluation = object.evaluation(invalid_input)
+        expect(evaluation.evaluations.length).to eql(1)
+      end
+    end
+  end
+
+  context 'intransitive' do
+
+    let(:valid_input)     { { 'foo' => 'bar' } }
+    let(:invalid_input)   { {}                 }
+    let(:expected_output) { true               }
+
+    let(:body_a) do
+      s(:key_fetch, 'foo')
+    end
+
+    let(:body_b) do
+      s(:primitive, String)
+    end
+
+    let(:expected_exception) do
+      Morpher::Evaluator::Transformer::TransformError.new(object.body.first, invalid_input)
+    end
+
+    include_examples 'intransitive evaluator'
+
+    context '#evaluation' do
+      subject { object.evaluation(valid_input) }
+
+      let(:evaluations) do
+        [
+          evaluator_a.evaluation(valid_input),
+          evaluator_b.evaluation('bar')
+        ]
+      end
+
+      context 'with valid input' do
+        it 'returns evaluation' do
+          should eql(
+            Morpher::Evaluation::Nary.new(
+              input:       valid_input,
+              evaluator:   object,
+              evaluations: evaluations,
+              output:      expected_output,
+              success:     true
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/spec/unit/morpher/evaluator/transformer/coerce/parse_int_spec.rb

@@ -0,0 +1,23 @@
+describe Morpher::Evaluator::Transformer::Coerce::ParseInt do
+  let(:object) { described_class.new(base) }
+
+  context 'base 16' do
+    let(:base) { 16 }
+
+    include_examples 'transitive evaluator'
+
+    let(:valid_input)     { 'ff'   }
+    let(:invalid_input)   { '0xfg' }
+    let(:expected_output) { 255    }
+  end
+
+  context 'base 10' do
+    let(:base) { 10 }
+
+    include_examples 'transitive evaluator'
+
+    let(:valid_input)     { '100'   }
+    let(:invalid_input)   { '100.0' }
+    let(:expected_output) { 100     }
+  end
+end

data/spec/unit/morpher/evaluator/transformer/custom_spec.rb

@@ -0,0 +1,13 @@
+describe Morpher::Evaluator::Transformer::Custom do
+  let(:object) { described_class.new(param) }
+
+  let(:param)  { [a, b] }
+
+  let(:a) { ->(_input) { :a } }
+  let(:b) { ->(_input) { :b } }
+
+  let(:valid_input)     { double('Input') }
+  let(:expected_output) { :a              }
+
+  include_examples 'transforming evaluator on valid input'
+end

data/spec/unit/morpher/evaluator/transformer/domain/attribute_accessors_spec.rb

@@ -0,0 +1,48 @@
+describe Morpher::Evaluator::Transformer::Domain::AttributeAccessors do
+
+  let(:model) do
+    Class.new do
+      include Equalizer.new(:foo, :bar)
+
+      attr_accessor :foo, :bar
+    end
+  end
+
+  let(:param) do
+    described_class::Param.new(model, %i[foo bar])
+  end
+
+  describe Morpher::Evaluator::Transformer::Domain::AttributeAccessors::Dump do
+
+    let(:object) { described_class::Dump.new(param) }
+
+    let(:expected_output) { { foo: :foo, bar: :bar } }
+
+    let(:valid_input) do
+      object = model.allocate
+      object.foo = :foo
+      object.bar = :bar
+      object
+    end
+
+    include_examples 'transforming evaluator on valid input'
+    include_examples 'transitive evaluator'
+
+  end
+
+  describe Morpher::Evaluator::Transformer::Domain::AttributeAccessors::Load do
+    let(:object) { described_class::Load.new(param) }
+
+    let(:valid_input)     { { foo: :foo, bar: :bar } }
+
+    let(:expected_output) do
+      object = model.allocate
+      object.foo = :foo
+      object.bar = :bar
+      object
+    end
+
+    include_examples 'transforming evaluator on valid input'
+    include_examples 'transitive evaluator'
+  end
+end