transproc 1.0.0 → 1.1.1

data/lib/transproc/transformer/class_interface.rb

@@ -1,7 +1,14 @@
+# frozen_string_literal: true
+
+require 'transproc/transformer/dsl'
+
 module Transproc
   class Transformer
-    # @api private
+    # @api public
     module ClassInterface
+      # @api private
+      attr_reader :dsl
+
       # Return a base Transproc::Transformer class with the
       # container configured to the passed argument.
       #
@@ -17,14 +24,18 @@ module Transproc
       #
       # @api public
       def [](container)
-        klass = Class.new(Transformer)
+        klass = Class.new(self)
         klass.container(container)
         klass
       end
 
       # @api private
       def inherited(subclass)
+        super
+
         subclass.container(@container) if defined?(@container)
+
+        subclass.instance_variable_set('@dsl', dsl.dup) if dsl
       end
 
       # Get or set the container to resolve transprocs from.
@@ -45,41 +56,33 @@ module Transproc
       # @return [Transproc::Registry]
       #
       # @api private
-      def container(container = ::Transproc::Undefined)
-        if container == ::Transproc::Undefined
-          ensure_container_presence!
-          @container
+      def container(container = Undefined)
+        if container.equal?(Undefined)
+          @container ||= Module.new.extend(Transproc::Registry)
         else
           @container = container
         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?
+      def import(*args)
+        container.import(*args)
+      end
+
+      # @api public
+      def define!(&block)
+        @dsl ||= DSL.new(container)
+        @dsl.instance_eval(&block)
+        self
+      end
 
-        Class.new(self).tap { |klass| klass.instance_eval(&block) }.transproc
+      # @api public
+      def new(*)
+        super.tap do |transformer|
+          transformer.instance_variable_set('@transproc', dsl.(transformer)) if dsl
+        end
       end
-      alias build define
+      ruby2_keywords(:new) if respond_to?(:ruby2_keywords, true)
 
       # Get a transformation from the container,
       # without adding it to the transformation pipeline
@@ -105,42 +108,6 @@ module Transproc
       def t(fn, *args)
         container[fn, *args]
       end
-
-      # @api private
-      def method_missing(method, *args, &block)
-        if container.contain?(method)
-          args.push(define(&block)) if block_given?
-          transformations << t(method, *args)
-        else
-          super
-        end
-      end
-
-      # @api private
-      def respond_to_missing?(method, _include_private = false)
-        container.contain?(method) || super
-      end
-
-      # @api private
-      def transproc
-        transformations.reduce(:>>)
-      end
-
-      private
-
-      # An array containing the transformation pipeline
-      #
-      # @api private
-      def transformations
-        @transformations ||= []
-      end
-
-      # @api private
-      def ensure_container_presence!
-        return if defined?(@container)
-        raise ArgumentError, 'Transformer function registry is empty. '\
-                             'Provide your registry via Transproc::Transformer[YourRegistry]'
-      end
     end
   end
 end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Transproc
+  class Transformer
+    module Deprecated
+      # @api public
+      module ClassInterface
+        # @api public
+        def new(*)
+          super.tap do |transformer|
+            transformer.instance_variable_set('@transproc', transproc) if transformations.any?
+          end
+        end
+        ruby2_keywords(:new) if respond_to?(:ruby2_keywords, true)
+
+        # @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.0'.freeze
+  VERSION = '1.1.1'.freeze
 end

data/spec/spec_helper.rb

@@ -1,19 +1,30 @@
-if RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter '/spec/'
+# frozen_string_literal: true
+
+if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
+  require 'yaml'
+  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
+  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
+
+  if RUBY_VERSION == latest_mri
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/spec/'
+    end
   end
 end
 
-require 'equalizer'
-require 'anima'
-require 'ostruct'
-require 'transproc/all'
+if defined? Warning
+  require 'warning'
+
+  Warning.ignore(/rspec/)
+  Warning.process { |w| raise RuntimeError, w } unless ENV['NO_WARNING']
+end
 
 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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+describe Transproc::ArrayTransformations do
+  describe '.combine' do
+    subject(:result) { described_class.t(:combine, mappings)[input] }
+
+    let(:input) { [[]] }
+    let(:mappings) { [] }
+
+    it { is_expected.to be_a(Array) }
+
+    it { is_expected.to eq([]) }
+
+    context 'without groups' do
+      let(:input) do
+        [
+          [
+            {name: 'Jane', email: 'jane@doe.org'}.freeze,
+            {name: 'Joe', email: 'joe@doe.org'}.freeze
+          ].freeze
+        ].freeze
+      end
+
+      it { is_expected.to eq input.first }
+    end
+
+    context 'with one group' do
+      let(:input) do
+        [
+          [
+            {name: 'Jane', email: 'jane@doe.org'}.freeze,
+            {name: 'Joe', email: 'joe@doe.org'}.freeze
+          ].freeze,
+          [
+            [
+              {user: 'Jane', title: 'One'}.freeze,
+              {user: 'Jane', title: 'Two'}.freeze,
+              {user: 'Joe', title: 'Three'}.freeze
+            ]
+          ]
+        ].freeze
+      end
+      let(:mappings) { [[:tasks, {name: :user}]] }
+
+      it 'merges hashes from arrays using provided join keys' do
+        output = [
+          {name: 'Jane', email: 'jane@doe.org', tasks: [
+            {user: 'Jane', title: 'One'},
+            {user: 'Jane', title: 'Two'}
+          ]},
+          {name: 'Joe', email: 'joe@doe.org', tasks: [
+            {user: 'Joe', title: 'Three'}
+          ]}
+        ]
+        is_expected.to eql(output)
+      end
+    end
+
+    context 'with empty nodes' do
+      let(:input) do
+        [
+          [{name: 'Jane', email: 'jane@doe.org'}.freeze].freeze,
+          [
+            []
+          ]
+        ].freeze
+      end
+
+      let(:mappings) { [[:tasks, {name: :user}]] }
+
+      it { is_expected.to eq([{name: 'Jane', email: 'jane@doe.org', tasks: []}]) }
+    end
+
+    context 'with double mapping' do
+      let(:input) do
+        [
+          [
+            {name: 'Jane', email: 'jane@doe.org'}.freeze
+          ].freeze,
+          [
+            [
+              {user: 'Jane', user_email: 'jane@doe.org', title: 'One'}.freeze,
+              {user: 'Jane', user_email: '', title: 'Two'}.freeze
+            ].freeze
+          ].freeze
+        ].freeze
+      end
+
+      let(:mappings) { [[:tasks, {name: :user, email: :user_email}]] }
+
+      it 'searches by two keys simultaneously' do
+        output = [
+          {name: 'Jane', email: 'jane@doe.org', tasks: [
+            {user: 'Jane', user_email: 'jane@doe.org', title: 'One'}
+          ]}
+        ]
+        is_expected.to eql(output)
+      end
+    end
+
+    context 'with non-array argument' do
+      let(:input) do
+        123
+      end
+
+      let(:mappings) { [[:page, {page_id: :id}]] }
+
+      it { is_expected.to eq(123) }
+    end
+
+    context 'with empty nested array' do
+      let(:input) do
+        [
+          [],
+          [
+            []
+          ]
+        ]
+      end
+
+      let(:mappings) { [[:menu_items, {id: :menu_id}, [[:page, {page_id: :id}]]]] }
+
+      it 'does not crash' do
+        expect { result }.not_to raise_error
+      end
+    end
+
+    context 'with enumerable input' do
+      let(:my_enumerator) do
+        Class.new do
+          include Enumerable
+          extend Forwardable
+
+          def_delegator :@array, :each
+
+          def initialize(array)
+            @array = array
+          end
+        end
+      end
+
+      let(:input) do
+        [
+          my_enumerator.new([
+            {name: 'Jane', email: 'jane@doe.org'}.freeze,
+            {name: 'Joe', email: 'joe@doe.org'}.freeze
+          ].freeze),
+          my_enumerator.new([
+            my_enumerator.new([
+              {user: 'Jane', title: 'One'}.freeze,
+              {user: 'Jane', title: 'Two'}.freeze,
+              {user: 'Joe', title: 'Three'}.freeze
+            ].freeze)
+          ].freeze)
+        ].freeze
+      end
+      let(:mappings) { [[:tasks, {name: :user}]] }
+
+      it 'supports enumerables as well' do
+        output = [
+          {name: 'Jane', email: 'jane@doe.org', tasks: [
+            {user: 'Jane', title: 'One'},
+            {user: 'Jane', title: 'Two'}
+          ]},
+          {name: 'Joe', email: 'joe@doe.org', tasks: [
+            {user: 'Joe', title: 'Three'}
+          ]}
+        ]
+        is_expected.to eql(output)
+      end
+    end
+
+    describe 'integration test' do
+      let(:input) do
+        [
+          [
+            {name: 'Jane', email: 'jane@doe.org'},
+            {name: 'Joe', email: 'joe@doe.org'}
+          ],
+          [
+            [
+              # user tasks
+              [
+                {user: 'Jane', title: 'One'},
+                {user: 'Jane', title: 'Two'},
+                {user: 'Joe', title: 'Three'}
+              ],
+              [
+                # task tags
+                [
+                  {task: 'One', tag: 'red'},
+                  {task: 'Three', tag: 'blue'}
+                ]
+              ]
+            ]
+          ]
+        ]
+      end
+
+      let(:mappings) { [[:tasks, {name: :user}, [[:tags, title: :task]]]] }
+
+      it 'merges hashes from arrays using provided join keys' do
+        output = [
+          {name: 'Jane', email: 'jane@doe.org', tasks: [
+            {user: 'Jane', title: 'One', tags: [{task: 'One', tag: 'red'}]},
+            {user: 'Jane', title: 'Two', tags: []}
+          ]},
+          {
+            name: 'Joe', email: 'joe@doe.org', tasks: [
+              {
+                user: 'Joe', title: 'Three', tags: [
+                  {task: 'Three', tag: 'blue'}
+                ]
+              }
+            ]
+          }
+        ]
+        is_expected.to eql(output)
+      end
+    end
+  end
+end