morpher 0.2.6

data/lib/morpher/printer/mixin.rb

@@ -0,0 +1,58 @@
+module Morpher
+  class Printer
+
+    # Printer behavior mixin
+    module Mixin
+
+      # Class level methods to be mixed in
+      module ClassMethods
+
+        # Register printer block for class
+        #
+        # @return [self]
+        #
+        # @api private
+        #
+        def printer(&block)
+          REGISTRY[self] = block
+        end
+
+      end # ClassMethods
+
+      # Instance level methods to be mixed in
+      module InstanceMethods
+
+        # Return description
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def description
+          io = StringIO.new
+          Printer.run(self, io)
+          io.rewind
+          io.read
+        end
+
+      end # InstanceMethods
+
+      # Callback whem module gets included
+      #
+      # @param [Class, Module] descendant
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.included(descendant)
+        descendant.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+      private_class_method :included
+
+    end # Mixin
+  end # Printer
+end # Morpher

data/lib/morpher/registry.rb

@@ -0,0 +1,51 @@
+module Morpher
+  # Mixin for to provide a node registry
+  module Registry
+
+    # Hook called when module is included
+    #
+    # @param [Module, Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.included(descendant)
+      descendant.const_set(:REGISTRY, {})
+      descendant.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    # Return node type
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    #
+    def type
+      self.class::TYPE
+    end
+
+    # Methods to get mixed in at singleton level
+    module ClassMethods
+
+      # Register evaluator under name
+      #
+      # TODO: Disallow duplicate registration under same name
+      #
+      # @param [Symbol] name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def register(name)
+        const_set(:TYPE, name)
+        self::REGISTRY[name] = self
+      end
+
+    end # ClassMethods
+
+  end # Registry
+end # Morpher

data/lib/morpher/type_lookup.rb

@@ -0,0 +1,51 @@
+module Morpher
+
+  # Type lookup via registry and superclass chaining
+  #
+  # TODO: Cache results.
+  #
+  class TypeLookup
+    include Adamantium::Flat, Concord.new(:registry)
+
+    # Error raised on compiling unknown nodes
+    class TypeNotFoundError < RuntimeError
+      include Concord.new(:type)
+
+      # Return exception error message
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def message
+        "Node type: #{type.inspect} is unknown"
+      end
+
+    end # TypeNotFoundError
+
+    # Perform type lookup
+    #
+    # @param [Object] object
+    #
+    # @return [Object]
+    #   if found
+    #
+    # @raise [TypeNotFoundError]
+    #   otherwise
+    #
+    # @api private
+    #
+    def call(object)
+      current = target = object.class
+      while current != Object
+        if registry.key?(current)
+          return registry.fetch(current)
+        end
+        current = current.superclass
+      end
+
+      fail TypeNotFoundError, target
+    end
+
+  end # TypeLookup
+end # Morpher

data/morpher.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'morpher'
+  gem.version     = '0.2.6'
+  gem.authors     = ['Markus Schirp']
+  gem.email       = ['mbj@schirp-dso.com']
+  gem.description = 'Composeable predicates on POROs'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/mbj/morpher'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- spec/{unit,integration}`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE]
+  gem.license          = 'MIT'
+
+  gem.required_ruby_version = ['>= 2.1']
+
+  gem.add_runtime_dependency('abstract_type', '~> 0.0.7')
+  gem.add_runtime_dependency('adamantium',    '~> 0.2.0')
+  gem.add_runtime_dependency('anima',         '~> 0.3.0')
+  gem.add_runtime_dependency('ast',           '~> 2.2')
+  gem.add_runtime_dependency('concord',       '~> 0.1.5')
+  gem.add_runtime_dependency('equalizer',     '~> 0.0.9')
+  gem.add_runtime_dependency('ice_nine',      '~> 0.11.0')
+  gem.add_runtime_dependency('procto',        '~> 0.0.2')
+
+  gem.add_development_dependency('devtools', '~> 0.1.3')
+end

data/spec/integration_spec.rb

@@ -0,0 +1,184 @@
+describe Morpher do
+
+  class Foo
+    include Anima.new(:attribute_a, :attribute_b)
+  end
+
+  class Bar
+    include Anima.new(:baz)
+  end
+
+  class Baz
+    include Anima.new(:value)
+  end
+
+  let(:tree_a) do
+    Foo.new(
+      attribute_a: Baz.new(value: :value_a),
+      attribute_b: :value_b
+    )
+  end
+
+  let(:transformer_ast) do
+    s(
+      :block,
+      s(:guard, s(:primitive, Hash)),
+      s(
+        :hash_transform,
+        s(
+          :key_symbolize,
+          :attribute_a,
+          s(:guard, s(:primitive, String))
+        ),
+        s(
+          :key_symbolize,
+          :attribute_b,
+          s(:guard, s(:primitive, Fixnum))
+        )
+      ),
+      s(:load_attribute_hash, s(:param, Foo))
+    )
+  end
+
+  let(:predicate_ast) do
+    s(
+      :block,
+      s(:key_fetch, :attribute_a),
+      s(:eql, s(:static, 'foo'), s(:input))
+    )
+  end
+
+  specify 'allows to execute a transformation' do
+    evaluator = Morpher.compile(transformer_ast)
+
+    valid = {
+      'attribute_a' => 'a string',
+      'attribute_b' => 8015
+    }
+
+    expect(evaluator.call(valid)).to eql(
+      Foo.new(attribute_a: 'a string', attribute_b: 8015)
+    )
+
+    evaluation = evaluator.evaluation(valid)
+
+    expect(evaluation.output).to eql(
+      Foo.new(attribute_a: 'a string', attribute_b: 8015)
+    )
+
+    invalid = {
+      'attribute_a' => 0,
+      'attribute_b' => 8015
+    }
+
+    expect { evaluator.call(invalid) }.to raise_error(Morpher::Evaluator::Transformer::TransformError)
+
+    evaluation = evaluator.evaluation(invalid)
+    expect(evaluation.success?).to be(false)
+  end
+
+  specify 'allows to inverse a transformations' do
+    evaluator = Morpher.compile(transformer_ast)
+
+    expect(evaluator.inverse.inverse).to eql(evaluator)
+
+    input = Foo.new(attribute_a: 'a string', attribute_b: 8015)
+
+    valid = {
+      'attribute_a' => 'a string',
+      'attribute_b' => 8015
+    }
+
+    expect(evaluator.inverse.call(input)).to eql(valid)
+  end
+
+  specify 'allows to merge inputs' do
+    evaluator = Morpher.compile(s(:merge, foo: :bar))
+
+    expect(evaluator.call(foo: :bar)).to eql(foo: :bar)
+    expect(evaluator.call(bar: :baz)).to eql(foo: :bar, bar: :baz)
+  end
+
+  specify 'allows to coerce inputs from string to int and back' do
+    evaluator = Morpher.compile(s(:parse_int, 10))
+
+    expect(evaluator.call('42')).to be(42)
+    expect(evaluator.inverse.call(42)).to eql('42')
+
+    evaluator = Morpher.compile(s(:int_to_string, 10))
+
+    expect(evaluator.call(42)).to eql('42')
+    expect(evaluator.inverse.call('42')).to be(42)
+  end
+
+  specify 'allows to coerce inputs from ISO8601 string to DateTime and back' do
+    evaluator = Morpher.compile(s(:parse_iso8601_date_time, 0))
+
+    iso8601_string = '2014-08-04T00:00:00+00:00'
+    date_time      = DateTime.new(2014, 8, 4)
+
+    expect(evaluator.call(iso8601_string)).to eq(date_time)
+    expect(evaluator.inverse.call(date_time)).to eq(iso8601_string)
+
+    evaluator = Morpher.compile(s(:date_time_to_iso8601_string, 0))
+
+    expect(evaluator.call(date_time)).to eq(iso8601_string)
+    expect(evaluator.inverse.call(iso8601_string)).to eq(date_time)
+  end
+
+  specify 'allows custom transformations' do
+    evaluator = Morpher.compile(s(:custom, [->(v) { "changed_#{v}" }]))
+
+    expect(evaluator.call('test')).to eql('changed_test')
+  end
+
+  specify 'allows predicates to be run from sexp' do
+
+    valid = { attribute_a: 'foo' }
+    invalid = { attribute_a: 'bar' }
+
+    evaluator = Morpher.compile(predicate_ast)
+
+    expect(evaluator.call(valid)).to be(true)
+    expect(evaluator.call(invalid)).to be(false)
+
+    evaluation = evaluator.evaluation(valid)
+
+    expect(evaluation.output).to be(true)
+    expect(evaluation.input).to be(valid)
+    expect(evaluation.description).to eql(strip(<<-TEXT))
+      Morpher::Evaluation::Nary
+        input: {:attribute_a=>"foo"}
+        output: true
+        success?: true
+        evaluator: Morpher::Evaluator::Transformer::Block
+        evaluations:
+          Morpher::Evaluation::Nullary
+            input: {:attribute_a=>"foo"}
+            output: "foo"
+            success?: true
+            evaluator:
+              Morpher::Evaluator::Transformer::Key::Fetch
+                param: :attribute_a
+          Morpher::Evaluation::Binary
+            input: "foo"
+            output: true
+            success?: true
+            left_evaluation:
+              Morpher::Evaluation::Nullary
+                input: "foo"
+                output: "foo"
+                success?: true
+                evaluator:
+                  Morpher::Evaluator::Transformer::Static
+                    param: "foo"
+            right_evaluation:
+              Morpher::Evaluation::Nullary
+                input: "foo"
+                output: "foo"
+                success?: true
+                evaluator:
+                  Morpher::Evaluator::Transformer::Input
+    TEXT
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/evaluator_behavior.rb

@@ -0,0 +1,155 @@
+shared_examples_for 'inverse evaluator' do
+  context '#inverse' do
+    subject { object.inverse }
+
+    it 'returns the expected inverse evaluator' do
+      should eql(expected_inverse)
+    end
+  end
+end
+
+shared_examples_for 'evaluator' do
+  it 'round trips transitive evaluators via #inverse' do
+    if object.kind_of?(Morpher::Evaluator::Transformer) && object.transitive?
+      object.inverse.inverse.should eql(object)
+    end
+  end
+
+  it 'round trips evaluators via #node' do
+    Morpher.compile(object.node).should eql(object)
+  end
+end
+
+shared_examples_for 'predicate evaluator' do
+  include_examples 'evaluator'
+
+  let(:negative_example?)        { true           }
+  let(:expected_output)          { true           }
+  let(:valid_input)              { positive_input }
+  let(:expected_positive_output) { true           }
+  let(:expected_negative_output) { false          }
+
+  context 'with positive input' do
+    it 'evaluates to positive output' do
+      expect(object.call(positive_input)).to be(expected_positive_output)
+    end
+
+    it 'evaluates to inverted positive output' do
+      expect(object.inverse.call(positive_input)).to be(!expected_positive_output)
+    end
+
+    it 'evaluates to the same output under #evaluation' do
+      evaluation = object.evaluation(positive_input)
+      expect(evaluation.success?).to be(true)
+      expect(evaluation.input).to be(positive_input)
+      expect(evaluation.output).to be(expected_positive_output)
+    end
+  end
+
+  context 'with negative input' do
+    it 'evaluates to false' do
+      expect(object.call(negative_input)).to be(false)
+    end
+
+    it 'evaluates to true on inverse' do
+      expect(object.inverse.call(negative_input)).to be(true)
+    end
+
+    it 'evaluates to the same output under #evaluation' do
+      evaluation = object.evaluation(negative_input)
+      expect(evaluation.input).to be(negative_input)
+      expect(evaluation.success?).to be(true)
+      expect(evaluation.output).to be(false)
+    end
+  end
+end
+
+shared_examples_for 'transitive evaluator' do
+  include_examples 'evaluator'
+
+  let(:invalid_input_example?) { true }
+
+  it 'signals transitivity via #transitive?' do
+    expect(object.transitive?).to be(true)
+  end
+
+  it 'round trips valid inputs via #evaluation' do
+    evaluation = object.evaluation(valid_input)
+    expect(evaluation.success?).to be(true)
+    evaluation = object.inverse.evaluation(evaluation.output)
+    expect(evaluation.output).to eql(valid_input)
+    expect(evaluation.success?).to be(true)
+  end
+
+  it 'round trips valid inputs via #call' do
+    forward = object.call(valid_input)
+    expect(object.inverse.call(forward)).to eql(valid_input)
+  end
+end
+
+shared_examples_for 'intransitive evaluator' do
+  include_examples 'evaluator'
+
+  let(:invalid_input_example?) { true }
+
+  it 'signals intransitivity via #transitive?' do
+    expect(object.transitive?).to be(false)
+  end
+end
+
+shared_examples_for 'transforming evaluator on valid input' do
+  include_examples 'evaluator'
+
+  it 'transforms to expected output via #call' do
+    result = object.call(valid_input)
+    expect(result).to eql(expected_output)
+  end
+
+  it 'transforms to expected output via #evaluation' do
+    evaluation = object.evaluation(valid_input)
+    expect(evaluation.success?).to eql(true)
+    expect(evaluation.output).to eql(expected_output)
+  end
+
+  specify '#evaluation' do
+    evaluation = object.evaluation(valid_input)
+    expect(evaluation.success?).to be(true)
+    expect(evaluation.evaluator).to eql(object)
+    expect(evaluation.input).to eql(valid_input)
+    expect(evaluation.output).to eql(expected_output)
+  end
+
+  specify '#call' do
+    expect(object.call(valid_input)).to eql(expected_output)
+  end
+end
+
+shared_examples_for 'transforming evaluator on invalid input' do
+  it 'raises error for #call' do
+    expect { object.call(invalid_input) }.to raise_error(
+      Morpher::Evaluator::Transformer::TransformError
+    )
+  end
+
+  it 'returns error evaluator for #evaluation' do
+    evaluation = object.evaluation(invalid_input)
+    expect(evaluation.success?).to eql(false)
+    expect(evaluation.output).to be(Morpher::Undefined)
+  end
+
+  let(:expected_exception) do
+    Morpher::Evaluator::Transformer::TransformError.new(object, invalid_input)
+  end
+
+  specify '#call' do
+    expect { object.call(invalid_input) }.to raise_error(expected_exception)
+  end
+
+  specify '#evaluation' do
+    evaluation = object.evaluation(invalid_input)
+    expect(evaluation.success?).to be(false)
+    expect(evaluation.evaluator).to eql(object)
+    expect(evaluation.input).to eql(invalid_input)
+    expect(evaluation.output).to eql(Morpher::Undefined)
+  end
+end