dry-transformer 0.1.0

data/lib/dry/transformer/store.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # Immutable collection of named procedures from external modules
+    #
+    # @api private
+    #
+    class Store
+      # @!attribute [r] methods
+      #
+      # @return [Hash] The associated list of imported procedures
+      #
+      attr_reader :methods
+
+      # @!scope class
+      # @!name new(methods = {})
+      # Creates an immutable store with a hash of procedures
+      #
+      # @param [Hash] methods
+      #
+      # @return [Dry::Transformer::Store]
+
+      # @private
+      def initialize(methods = {})
+        @methods = methods.dup.freeze
+        freeze
+      end
+
+      # Returns a procedure by its key in the collection
+      #
+      # @param [Symbol] key
+      #
+      # @return [Proc]
+      #
+      def fetch(key)
+        methods.fetch(key)
+      end
+
+      # Returns wether the collection contains such procedure by its key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Boolean]
+      #
+      def contain?(key)
+        methods.key?(key)
+      end
+
+      # Register a new function
+      #
+      # @example
+      #   store.register(:to_json, -> v { v.to_json })
+
+      #   store.register(:to_json) { |v| v.to_json }
+      #
+      def register(name, fn = nil, &block)
+        self.class.new(methods.merge(name => fn || block))
+      end
+
+      # Imports proc(s) to the collection from another module
+      #
+      # @private
+      #
+      def import(*args)
+        first = args.first
+        return import_all(first) if first.instance_of?(Module)
+
+        opts   = args.pop
+        source = opts.fetch(:from)
+        rename = opts.fetch(:as) { first.to_sym }
+
+        return import_methods(source, args) if args.count > 1
+
+        import_method(source, first, rename)
+      end
+
+      protected
+
+      # Creates new immutable collection from the current one,
+      # updated with either the module's singleton method,
+      # or the proc having been imported from another module.
+      #
+      # @param [Module] source
+      # @param [Symbol] name
+      # @param [Symbol] new_name
+      #
+      # @return [Dry::Transformer::Store]
+      #
+      def import_method(source, name, new_name = name)
+        from = name.to_sym
+        to   = new_name.to_sym
+
+        fn = source.is_a?(Registry) ? source.fetch(from) : source.method(from)
+        self.class.new(methods.merge(to => fn))
+      end
+
+      # Creates new immutable collection from the current one,
+      # updated with either the module's singleton methods,
+      # or the procs having been imported from another module.
+      #
+      # @param [Module] source
+      # @param [Array<Symbol>] names
+      #
+      # @return [Dry::Transformer::Store]
+      #
+      def import_methods(source, names)
+        names.inject(self) { |a, e| a.import_method(source, e) }
+      end
+
+      # Creates new immutable collection from the current one,
+      # updated with all singleton methods and imported methods
+      # from the other module
+      #
+      # @param [Module] source The module to import procedures from
+      #
+      # @return [Dry::Transformer::Store]
+      #
+      def import_all(source)
+        names = source.public_methods - Registry.instance_methods - Module.methods
+        names -= [:initialize] # for compatibility with Rubinius
+        names += source.store.methods.keys if source.is_a? Registry
+
+        import_methods(source, names)
+      end
+    end
+  end
+end

data/lib/dry/transformer/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    VERSION = '0.1.0'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+if ENV['COVERAGE'] == 'true'
+  require 'codacy-coverage'
+  Codacy::Reporter.start
+end
+
+begin
+  require 'byebug'
+rescue LoadError;end
+
+require 'dry/transformer/all'
+
+root = Pathname(__FILE__).dirname
+Dir[root.join('support/*.rb').to_s].each { |f| require f }
+
+# Namespace holding all objects created during specs
+module Test
+  def self.remove_constants
+    constants.each(&method(:remove_const))
+  end
+end
+
+RSpec.configure do |config|
+  config.after do
+    Test.remove_constants
+  end
+
+  config.disable_monkey_patching!
+  config.warnings = true
+end

data/spec/unit/array/combine_spec.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+RSpec.describe Dry::Transformer::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

data/spec/unit/array_transformations_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+RSpec.describe Dry::Transformer::ArrayTransformations do
+  let(:hashes) { Dry::Transformer::HashTransformations }
+
+  describe '.extract_key' do
+    it 'extracts values by key from all hashes' do
+      extract_key = described_class.t(:extract_key, 'name')
+
+      input = [
+        { 'name' => 'Alice', 'role' => 'sender' },
+        { 'name' => 'Bob', 'role' => 'receiver' },
+        { 'role' => 'listener' }
+      ].freeze
+
+      output = ['Alice', 'Bob', nil]
+
+      expect(extract_key[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:extract_key!) }
+
+  describe '.insert_key' do
+    it 'wraps values to tuples with given key' do
+      insert_key = described_class.t(:insert_key, 'name')
+
+      input = ['Alice', 'Bob', nil].freeze
+
+      output = [
+        { 'name' => 'Alice' },
+        { 'name' => 'Bob' },
+        { 'name' => nil }
+      ]
+
+      expect(insert_key[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:insert_key!) }
+
+  describe '.add_keys' do
+    it 'returns a new array with missed keys added to tuples' do
+      add_keys = described_class.t(:add_keys, [:foo, :bar, :baz])
+
+      input = [{ foo: 'bar' }, { bar: 'baz' }].freeze
+
+      output = [
+        { foo: 'bar', bar: nil, baz: nil },
+        { foo: nil, bar: 'baz', baz: nil }
+      ]
+
+      expect(add_keys[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:add_keys!) }
+
+  describe '.map_array' do
+    it 'applies funtions to all values' do
+      map = described_class.t(:map_array, hashes[:symbolize_keys])
+
+      input = [
+        { 'name' => 'Jane', 'title' => 'One' }.freeze,
+        { 'name' => 'Jane', 'title' => 'Two' }.freeze
+      ].freeze
+
+      output = [
+        { name: 'Jane', title: 'One' },
+        { name: 'Jane', title: 'Two' }
+      ]
+
+      expect(map[input]).to eql(output)
+    end
+
+    it 'handles huge arrays' do
+      map = described_class.t(:map_array, hashes[:symbolize_keys])
+
+      input = Array.new(138_706) { |i| { 'key' => i } }
+
+      expect { map[input] }.to_not raise_error
+    end
+
+    it 'handles flat value arrays' do
+      map = described_class.t(:map_array, :upcase.to_proc)
+
+      expect(map['foo']).to eql(%w(FOO))
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:map_array!) }
+
+  describe '.wrap' do
+    it 'returns a new array with wrapped hashes' do
+      wrap = described_class.t(:wrap, :task, [:title])
+
+      input = [{ name: 'Jane', title: 'One' }]
+      output = [{ name: 'Jane', task: { title: 'One' } }]
+
+      expect(wrap[input]).to eql(output)
+    end
+
+    it 'returns a array new with deeply wrapped hashes' do
+      wrap =
+        described_class.t(
+          :map_array,
+          hashes[:nest, :user, [:name, :title]] +
+          hashes[:map_value, :user, hashes[:nest, :task, [:title]]]
+        )
+
+      input = [{ name: 'Jane', title: 'One' }]
+      output = [{ user: { name: 'Jane', task: { title: 'One' } } }]
+
+      expect(wrap[input]).to eql(output)
+    end
+
+    it 'adds data to the existing tuples' do
+      wrap = described_class.t(:wrap, :task, [:title])
+
+      input  = [{ name: 'Jane', task: { priority: 1 }, title: 'One' }]
+      output = [{ name: 'Jane', task: { priority: 1, title: 'One' } }]
+
+      expect(wrap[input]).to eql(output)
+    end
+  end
+
+  describe '.group' do
+    subject(:group) { described_class.t(:group, :tasks, [:title]) }
+
+    it 'returns a new array with grouped hashes' do
+      input  = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+      output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
+
+      expect(group[input]).to eql(output)
+    end
+
+    it 'updates the existing group' do
+      input  = [
+        {
+          name: 'Jane',
+          title: 'One',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        },
+        {
+          name: 'Jane',
+          title: 'Two',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        }
+      ]
+      output = [
+        {
+          name: 'Jane',
+          tasks: [
+            { title: 'One', type: 'one' },
+            { title: 'One', type: 'two' },
+            { title: 'Two', type: 'one' },
+            { title: 'Two', type: 'two' }
+          ]
+        }
+      ]
+
+      expect(group[input]).to eql(output)
+    end
+
+    it 'ingnores old values except for array of tuples' do
+      input  = [
+        { name: 'Jane', title: 'One',   tasks: [{ priority: 1 }, :wrong] },
+        { name: 'Jane', title: 'Two',   tasks: :wrong }
+      ]
+      output = [
+        {
+          name: 'Jane',
+          tasks: [{ title: 'One', priority: 1 }, { title: 'Two' }]
+        }
+      ]
+
+      expect(group[input]).to eql(output)
+    end
+  end
+
+  describe '.ungroup' do
+    subject(:ungroup) { described_class.t(:ungroup, :tasks, [:title]) }
+
+    it 'returns a new array with ungrouped hashes' do
+      input = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
+      output = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+
+      expect(ungroup[input]).to eql(output)
+    end
+
+    it 'returns an input with empty array removed' do
+      input = [{ name: 'Jane', tasks: [] }]
+      output = [{ name: 'Jane' }]
+
+      expect(ungroup[input]).to eql(output)
+    end
+
+    it 'returns an input when a key is absent' do
+      input = [{ name: 'Jane' }]
+      output = [{ name: 'Jane' }]
+
+      expect(ungroup[input]).to eql(output)
+    end
+
+    it 'ungroups array partially' do
+      input = [
+        {
+          name: 'Jane',
+          tasks: [
+            { title: 'One', type: 'one' },
+            { title: 'One', type: 'two' },
+            { title: 'Two', type: 'one' },
+            { title: 'Two', type: 'two' }
+          ]
+        }
+      ]
+      output = [
+        {
+          name: 'Jane',
+          title: 'One',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        },
+        {
+          name: 'Jane',
+          title: 'Two',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        }
+      ]
+
+      expect(ungroup[input]).to eql(output)
+    end
+  end
+end