transproc 1.0.3 → 1.1.0

data/lib/transproc/transformer/deprecated/class_interface.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Transproc
+  class Transformer
+    module Deprecated
+      # @api public
+      module ClassInterface
+        # @api public
+        def new(*args)
+          super(*args).tap do |transformer|
+            transformer.instance_variable_set('@transproc', transproc) if transformations.any?
+          end
+        end
+
+        # @api private
+        def inherited(subclass)
+          super
+
+          if transformations.any?
+            subclass.instance_variable_set('@transformations', transformations.dup)
+          end
+        end
+
+        # Define an anonymous transproc derived from given Transformer
+        # Evaluates block with transformations and returns initialized transproc.
+        # Does not mutate original Transformer
+        #
+        # @example
+        #
+        #   class MyTransformer < Transproc::Transformer[MyContainer]
+        #   end
+        #
+        #   transproc = MyTransformer.define do
+        #     map_values t(:to_string)
+        #   end
+        #   transproc.call(a: 1, b: 2)
+        #   # => {a: '1', b: '2'}
+        #
+        # @yield Block allowing to define transformations. The same as class level DSL
+        #
+        # @return [Function] Composed transproc
+        #
+        # @api public
+        def define(&block)
+          return transproc unless block_given?
+
+          Class.new(Transformer[container]).tap { |klass| klass.instance_eval(&block) }.transproc
+        end
+        alias build define
+
+        # @api private
+        def method_missing(method, *args, &block)
+          super unless container.contain?(method)
+          func = block ? t(method, *args, define(&block)) : t(method, *args)
+          transformations << func
+          func
+        end
+
+        # @api private
+        def respond_to_missing?(method, _include_private = false)
+          super || container.contain?(method)
+        end
+
+        # @api private
+        def transproc
+          transformations.reduce(:>>)
+        end
+
+        private
+
+        # An array containing the transformation pipeline
+        #
+        # @api private
+        def transformations
+          @transformations ||= []
+        end
+      end
+    end
+  end
+end

data/lib/transproc/transformer/dsl.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'transproc/compiler'
+
+module Transproc
+  class Transformer
+    # @api public
+    class DSL
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :ast
+
+      # @api private
+      def initialize(container, ast: [], &block)
+        @container = container
+        @ast = ast
+        instance_eval(&block) if block
+      end
+
+      # @api private
+      def dup
+        self.class.new(container, ast: ast.dup)
+      end
+
+      # @api private
+      def call(transformer)
+        Compiler.new(container, transformer).(ast)
+      end
+
+      private
+
+      # @api private
+      def node(&block)
+        [:t, self.class.new(container, &block).ast]
+      end
+
+      # @api private
+      def respond_to_missing?(method, _include_private = false)
+        super || container.contain?(method)
+      end
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        arg_nodes = *args.map { |a| [:arg, a] }
+        ast << [:fn, (block ? [meth, [*arg_nodes, node(&block)]] : [meth, arg_nodes])]
+      end
+    end
+  end
+end

data/lib/transproc/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
-  VERSION = '1.0.3'.freeze
+  VERSION = '1.1.0'.freeze
 end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
   require 'yaml'
   rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
@@ -11,15 +13,11 @@ if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
   end
 end
 
-require 'equalizer'
-require 'anima'
-require 'ostruct'
-require 'transproc/all'
-
 begin
   require 'byebug'
-rescue LoadError
-end
+rescue LoadError;end
+
+require 'transproc/all'
 
 root = Pathname(__FILE__).dirname
 Dir[root.join('support/*.rb').to_s].each { |f| require f }

data/spec/unit/array/combine_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require 'forwardable'
 
 describe Transproc::ArrayTransformations do
   describe '.combine' do

data/spec/unit/array_transformations_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::ArrayTransformations do
   let(:hashes) { Transproc::HashTransformations }

data/spec/unit/class_transformations_spec.rb

@@ -1,9 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require 'dry/equalizer'
 
 describe Transproc::ClassTransformations do
   describe '.constructor_inject' do
     let(:klass) do
-      Struct.new(:name, :age) { include Equalizer.new(:name, :age) }
+      Struct.new(:name, :age) { include Dry::Equalizer.new(:name, :age) }
     end
 
     it 'returns a new object initialized with the given arguments' do
@@ -21,12 +23,13 @@ describe Transproc::ClassTransformations do
   describe '.set_ivars' do
     let(:klass) do
       Class.new do
-        include Anima.new(:name, :age)
+        include Dry::Equalizer.new(:name, :age)
 
-        attr_reader :test
+        attr_reader :name, :age, :test
 
-        def initialize(*args)
-          super
+        def initialize(name:, age:)
+          @name = name
+          @age = age
           @test = true
         end
       end

data/spec/unit/coercions_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Coercions do
   describe '.identity' do

data/spec/unit/composer_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Composer do
   before do

data/spec/unit/conditional_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Conditional do
   describe '.not' do

data/spec/unit/function_not_found_error_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 describe Transproc::FunctionNotFoundError do
   it 'complains that the function not registered' do

data/spec/unit/function_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Function do
   let(:container) do

data/spec/unit/hash_transformations_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::HashTransformations do
   describe '.map_keys' do
@@ -50,6 +50,17 @@ describe Transproc::HashTransformations do
     end
   end
 
+  describe '.deep_stringify_keys' do
+    it 'returns a new hash with symbolized keys' do
+      stringify_keys = described_class.t(:deep_stringify_keys)
+
+      input = { foo: 'bar', baz: [{ one: 1 }, 'two'] }
+      output = { 'foo' => 'bar', 'baz' => [{ 'one' => 1 }, 'two'] }
+
+      expect(stringify_keys[input]).to eql(output)
+    end
+  end
+
   it { expect(described_class).not_to be_contain(:stringify_keys!) }
 
   describe '.map_values' do

data/spec/unit/proc_transformations_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require 'ostruct'
 
 describe Transproc::ProcTransformations do
   describe '.bind' do

data/spec/unit/recursion_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Recursion do
   let(:hashes) { Transproc::HashTransformations }

data/spec/unit/registry_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Registry do
   before { module Transproc::Test; end         }

data/spec/unit/store_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 describe Transproc::Store do
   let(:store) { described_class.new methods      }
@@ -186,6 +186,7 @@ describe Transproc::Store do
       end
 
       it 'skips Transproc::Registry singleton methods' do
+        pending "this fails for some reason" if RUBY_ENGINE == "jruby"
         expect(subject.methods.keys).to contain_exactly(:foo, :bar, :baz, :qux)
       end
     end

data/spec/unit/transformer/class_interface_spec.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'dry/equalizer'
+
+describe Transproc::Transformer do
+  let(:container) { Module.new { extend Transproc::Registry } }
+  let(:klass) { Transproc::Transformer[container] }
+  let(:transformer) { klass.new }
+
+  describe '.import' do
+    it 'allows importing functions into an auto-configured registry' do
+      klass = Class.new(Transproc::Transformer) do
+        import Transproc::ArrayTransformations
+        import Transproc::Coercions
+
+        define! do
+          map_array(&:to_symbol)
+        end
+      end
+
+      transformer = klass.new
+
+      expect(transformer.(['foo', 'bar'])).to eql([:foo, :bar])
+    end
+  end
+
+  describe '.new' do
+    it 'supports arguments' do
+      klass = Class.new(Transproc::Transformer) do
+        import Transproc::ArrayTransformations
+        import Transproc::Coercions
+
+        define! do
+          map_array(&:to_symbol)
+        end
+
+        def initialize(good)
+          @good = good
+        end
+
+        def good?
+          @good
+        end
+      end
+
+      transformer = klass.new(true)
+
+      expect(transformer).to be_good
+    end
+  end
+
+  describe '.container' do
+    it 'returns the configured container' do
+      expect(klass.container).to be(container)
+    end
+
+    context 'with setter argument' do
+      let(:container) { double(:custom_container) }
+
+      it 'sets and returns the container' do
+        klass.container(container)
+
+        expect(klass.container).to be(container)
+      end
+    end
+  end
+
+  describe 'inheritance' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        def self.arbitrary(value, fn)
+          fn[value]
+        end
+      end
+    end
+
+    let(:superclass) do
+      Class.new(Transproc::Transformer[container]) do
+        define! do
+          arbitrary ->(v) { v + 1 }
+        end
+      end
+    end
+
+    let(:subclass) do
+      Class.new(superclass) do
+        define! do
+          arbitrary ->(v) { v * 2 }
+        end
+      end
+    end
+
+    it 'inherits container from superclass' do
+      expect(subclass.container).to be(superclass.container)
+    end
+
+    it 'inherits transproc from superclass' do
+      expect(superclass.new.call(2)).to be(3)
+      expect(subclass.new.call(2)).to be(6)
+    end
+  end
+
+  describe '.[]' do
+    subject(:subclass) { klass[another_container] }
+
+    let(:another_container) { double('Transproc') }
+
+    it 'sets a container' do
+      expect(subclass.container).to be(another_container)
+    end
+
+    it 'returns a class' do
+      expect(subclass).to be_a(Class)
+    end
+
+    it 'creates a subclass of Transformer' do
+      expect(subclass).to be < Transproc::Transformer
+    end
+
+    it 'does not change super class' do
+      expect(klass.container).to be(container)
+    end
+
+    it 'does not inherit transproc' do
+      expect(klass[container].new.transproc).to be_nil
+    end
+
+    context 'with predefined transformer' do
+      let(:klass) do
+        Class.new(Transproc::Transformer[container]) do
+          container.import Transproc::Coercions
+          container.import Transproc::HashTransformations
+
+          map_value :attr, t(:to_symbol)
+        end
+      end
+
+      it "inherits parent's transproc" do
+        expect(klass[container].new.transproc).to eql(klass.new.transproc)
+      end
+    end
+  end
+
+  describe '.define' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+
+        def self.to_symbol(v)
+          v.to_sym
+        end
+      end
+    end
+
+    let(:klass) { Transproc::Transformer[container] }
+
+    it 'defines anonymous transproc' do
+      transproc = klass.define do
+        map_value(:attr, t(:to_symbol))
+      end
+
+      expect(transproc[attr: 'abc']).to eq(attr: :abc)
+    end
+
+    it 'has .build alias' do
+      transproc = klass.build do
+        map_value(:attr, t(:to_symbol))
+      end
+
+      expect(transproc[attr: 'abc']).to eq(attr: :abc)
+    end
+
+    it 'does not affect original transformer' do
+      klass.define do
+        map_value(:attr, :to_sym.to_proc)
+      end
+
+      expect(klass.new.transproc).to be_nil
+    end
+
+    context 'with custom container' do
+      let(:container) do
+        Module.new do
+          extend Transproc::Registry
+
+          def self.arbitrary(value, fn)
+            fn[value]
+          end
+        end
+      end
+
+      let(:klass) { described_class[container] }
+
+      it 'uses a container from the transformer' do
+        transproc = klass.define! do
+          arbitrary ->(v) { v + 1 }
+        end.new
+
+        expect(transproc.call(2)).to eq 3
+      end
+    end
+
+    context 'with predefined transformer' do
+      let(:klass) do
+        Class.new(described_class[container]) do
+          define! do
+            map_value :attr, ->(v) { v + 1 }
+          end
+        end
+      end
+
+      it 'builds transformation from the DSL definition' do
+        transproc = klass.new
+
+        expect(transproc.call(attr: 2)).to eql(attr: 3)
+      end
+    end
+  end
+
+  describe '.t' do
+    subject(:klass) { Transproc::Transformer[container] }
+
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+        import Transproc::Conditional
+
+        def self.custom(value, suffix)
+          value + suffix
+        end
+      end
+    end
+
+    it 'returns a registed function' do
+      expect(klass.t(:custom, '_bar')).to eql(container[:custom, '_bar'])
+    end
+
+    it 'is useful in DSL' do
+      transproc = Class.new(klass) do
+        map_value :a, t(:custom, '_bar')
+      end.new
+
+      expect(transproc.call(a: 'foo')).to eq(a: 'foo_bar')
+    end
+
+    it 'works in nested block' do
+      transproc = Class.new(klass) do
+        map_values do
+          is String, t(:custom, '_bar')
+        end
+      end.new
+
+      expect(transproc.call(a: 'foo', b: :symbol)).to eq(a: 'foo_bar', b: :symbol)
+    end
+  end
+
+  describe '.method_missing' do
+    it 'responds to missing when there is a corresponding function' do
+      container.import Transproc::HashTransformations
+
+      expect(klass.method(:map_values)).to be_a(Method)
+    end
+
+    it 'raises when there is no corresponding function or instance method' do
+      expect { klass.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+
+  describe '#call' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+        import Transproc::ArrayTransformations
+        import Transproc::ClassTransformations
+      end
+    end
+
+    let(:klass) do
+      Class.new(Transproc::Transformer[container]) do
+        map_array do
+          symbolize_keys
+          rename_keys user_name: :name
+          nest :address, [:city, :street, :zipcode]
+
+          map_value :address do
+            constructor_inject Test::Address
+          end
+
+          constructor_inject Test::User
+        end
+      end
+    end
+
+    let(:input) do
+      [
+        { 'user_name' => 'Jane',
+          'city' => 'NYC',
+          'street' => 'Street 1',
+          'zipcode' => '123'
+        }
+      ]
+    end
+
+    let(:expected_output) do
+      [
+        Test::User.new(
+          name: 'Jane',
+          address: Test::Address.new(
+            city: 'NYC',
+            street: 'Street 1',
+            zipcode: '123'
+          )
+        )
+      ]
+    end
+
+    before do
+      module Test
+        class User < OpenStruct
+          include Dry::Equalizer(:name, :address)
+        end
+
+        class Address < OpenStruct
+          include Dry::Equalizer(:city, :street, :zipcode)
+        end
+      end
+    end
+
+    it "transforms input" do
+      expect(transformer.(input)).to eql(expected_output)
+    end
+
+    context 'with custom registry' do
+      let(:klass) do
+        Class.new(Transproc::Transformer[registry]) do
+          append ' is awesome'
+        end
+      end
+
+      let(:registry) do
+        Module.new do
+          extend Transproc::Registry
+
+          def self.append(value, suffix)
+            value + suffix
+          end
+        end
+      end
+
+      it 'uses custom functions' do
+        expect(transformer.('transproc')).to eql('transproc is awesome')
+      end
+    end
+  end
+end