dry-transformer 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '07286bcabed176ae3f17868f5e838decc2ba0c192828b6e69da92ec18f8713e0'
+  data.tar.gz: 3c5b577d2fc463182fd9fb28a333b594622c4afa61b276183f3247ce757c55e8
+SHA512:
+  metadata.gz: e100d0e8782d778c4abf0c6f805bfbcafd1d86ce5876a898706114fa658ed3c3045345470adc6bd44a750b995a92d0033d95fadbe0e565bca5fccd52d7b4a993
+  data.tar.gz: 41ea28575f7d9691f8e36e14920b4a65718738086a96ebc5b73cee2f3108d8884a99f6da0b933c17b1cf270a314a93fbb39c4b30eb4c51cc0736d690b22be662

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# 2020-01-14
+
+## Fixed
+
+Fixed Dry::Transformer::HashTransformations.unwrap when hash contains root key (@AMHOL)
+
+[Compare v0.1.0...v0.1.1](https://github.com/dry-rb/dry-transaction/compare/v0.1.0...v0.1.1)
+
+# v0.1.0 2019-12-28
+
+Initial port of the [transproc](https://github.com/solnic/transproc) gem.

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2020 dry-rb team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+[gem]: https://rubygems.org/gems/dry-transformer
+[actions]: https://github.com/dry-rb/dry-transformer/actions
+[codacy]: https://www.codacy.com/gh/dry-rb/dry-transformer
+[chat]: https://dry-rb.zulipchat.com
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-transformer
+
+# dry-transformer [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
+
+[![Gem Version](https://badge.fury.io/rb/dry-transformer.svg)][gem]
+[![CI Status](https://github.com/dry-rb/dry-transformer/workflows/ci/badge.svg)][actions]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/22edf59617be4aef97cfbe4e1c99f1ce)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/22edf59617be4aef97cfbe4e1c99f1ce)][codacy]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-transformer.svg?branch=master)][inchpages]
+
+## Links
+
+* [User documentation](http://dry-rb.org/gems/dry-transformer)
+* [API documentation](http://rubydoc.info/gems/dry-transformer)
+
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
+
+* MRI >= `2.4`
+* jruby >= `9.2`
+
+## License
+
+See `LICENSE` file.

data/dry-transformer.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# this file is managed by dry-rb/devtools project
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dry/transformer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-transformer'
+  spec.authors       = ["Piotr Solnica"]
+  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.license       = 'MIT'
+  spec.version       = Dry::Transformer::VERSION.dup
+
+  spec.summary       = "Data transformation toolkit"
+  spec.description   = spec.summary
+  spec.homepage      = 'https://dry-rb.org/gems/dry-transformer'
+  spec.files         = Dir['CHANGELOG.md', 'LICENSE', 'README.md', 'dry-transformer.gemspec', 'lib/**/*']
+  spec.require_paths = ['lib']
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['changelog_uri']     = 'https://github.com/dry-rb/dry-transformer/blob/master/CHANGELOG.md'
+  spec.metadata['source_code_uri']   = 'https://github.com/dry-rb/dry-transformer'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/dry-rb/dry-transformer/issues'
+
+  spec.required_ruby_version = '>= 2.4.0'
+
+  # to update dependencies edit project.yml
+end

data/lib/dry-transformer.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dry/transformer'

data/lib/dry/transformer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/version'
+require 'dry/transformer/constants'
+require 'dry/transformer/function'
+require 'dry/transformer/error'
+require 'dry/transformer/store'
+require 'dry/transformer/registry'
+
+require 'dry/transformer/array'
+require 'dry/transformer/hash'
+
+require 'dry/transformer/pipe'
+
+module Dry
+  module Transformer
+    # @api public
+    # @see Pipe.[]
+    def self.[](registry)
+      Pipe[registry]
+    end
+  end
+end

data/lib/dry/transformer/all.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'dry/transformer'
+
+require 'dry/transformer/class'
+require 'dry/transformer/coercions'
+require 'dry/transformer/conditional'
+require 'dry/transformer/array'
+require 'dry/transformer/hash'
+require 'dry/transformer/proc'
+require 'dry/transformer/recursion'

data/lib/dry/transformer/array.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/coercions'
+require 'dry/transformer/hash'
+require 'dry/transformer/array/combine'
+
+module Dry
+  module Transformer
+    # Transformation functions for Array objects
+    #
+    # @example
+    #   require 'dry/transformer/array'
+    #
+    #   include Dry::Transformer::Helper
+    #
+    #   fn = t(:map_array, t(:symbolize_keys)) >> t(:wrap, :address, [:city, :zipcode])
+    #
+    #   fn.call(
+    #     [
+    #       { 'city' => 'Boston', 'zipcode' => '123' },
+    #       { 'city' => 'NYC', 'zipcode' => '312' }
+    #     ]
+    #   )
+    #   # => [{:address=>{:city=>"Boston", :zipcode=>"123"}}, {:address=>{:city=>"NYC", :zipcode=>"312"}}]
+    #
+    # @api public
+    module ArrayTransformations
+      extend Registry
+
+      # Map array values using transformation function
+      #
+      # @example
+      #
+      #   fn = Dry::Transformer(:map_array, -> v { v.upcase })
+      #
+      #   fn.call ['foo', 'bar'] # => ["FOO", "BAR"]
+      #
+      # @param [Array] array The input array
+      # @param [Proc] fn The transformation function
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.map_array(array, fn)
+        Array(array).map { |value| fn[value] }
+      end
+
+      # Wrap array values using HashTransformations.nest function
+      #
+      # @example
+      #   fn = Dry::Transformer(:wrap, :address, [:city, :zipcode])
+      #
+      #   fn.call [{ city: 'NYC', zipcode: '123' }]
+      #   # => [{ address: { city: 'NYC', zipcode: '123' } }]
+      #
+      # @param [Array] array The input array
+      # @param [Object] key The nesting root key
+      # @param [Object] keys The nesting value keys
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.wrap(array, key, keys)
+        nest = HashTransformations[:nest, key, keys]
+        array.map { |element| nest.call(element) }
+      end
+
+      # Group array values using provided root key and value keys
+      #
+      # @example
+      #   fn = Dry::Transformer(:group, :tags, [:tag])
+      #
+      #   fn.call [
+      #     { task: 'Group it', tag: 'task' },
+      #     { task: 'Group it', tag: 'important' }
+      #   ]
+      #   # => [{ task: 'Group it', tags: [{ tag: 'task' }, { tag: 'important' }]]
+      #
+      # @param [Array] array The input array
+      # @param [Object] key The nesting root key
+      # @param [Object] keys The nesting value keys
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.group(array, key, keys)
+        grouped = Hash.new { |h, k| h[k] = [] }
+        array.each do |hash|
+          hash = Hash[hash]
+
+          old_group = Coercions.to_tuples(hash.delete(key))
+          new_group = keys.inject({}) { |a, e| a.merge(e => hash.delete(e)) }
+
+          grouped[hash] << old_group.map { |item| item.merge(new_group) }
+        end
+        grouped.map do |root, children|
+          root.merge(key => children.flatten)
+        end
+      end
+
+      # Ungroup array values using provided root key and value keys
+      #
+      # @example
+      #   fn = Dry::Transformer(:ungroup, :tags, [:tag])
+      #
+      #   fn.call [
+      #     { task: 'Group it', tags: [{ tag: 'task' }, { tag: 'important' }] }
+      #   ]
+      #   # => [
+      #     { task: 'Group it', tag: 'task' },
+      #     { task: 'Group it', tag: 'important' }
+      #   ]
+      #
+      # @param [Array] array The input array
+      # @param [Object] key The nesting root key
+      # @param [Object] keys The nesting value keys
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.ungroup(array, key, keys)
+        array.flat_map { |item| HashTransformations.split(item, key, keys) }
+      end
+
+      def self.combine(array, mappings)
+        Combine.combine(array, mappings)
+      end
+
+      # Converts the array of hashes to array of values, extracted by given key
+      #
+      # @example
+      #   fn = t(:extract_key, :name)
+      #   fn.call [
+      #     { name: 'Alice', role: 'sender' },
+      #     { name: 'Bob', role: 'receiver' },
+      #     { role: 'listener' }
+      #   ]
+      #   # => ['Alice', 'Bob', nil]
+      #
+      # @param [Array<Hash>] array The input array of hashes
+      # @param [Object] key The key to extract values by
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.extract_key(array, key)
+        map_array(array, ->(v) { v[key] })
+      end
+
+      # Wraps every value of the array to tuple with given key
+      #
+      # The transformation partially inverses the `extract_key`.
+      #
+      # @example
+      #   fn = t(:insert_key, 'name')
+      #   fn.call ['Alice', 'Bob', nil]
+      #   # => [{ 'name' => 'Alice' }, { 'name' => 'Bob' }, { 'name' => nil }]
+      #
+      # @param [Array<Hash>] array The input array of hashes
+      # @param [Object] key The key to extract values by
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.insert_key(array, key)
+        map_array(array, ->(v) { { key => v } })
+      end
+
+      # Adds missing keys with nil value to all tuples in array
+      #
+      # @param [Array] keys
+      #
+      # @return [Array]
+      #
+      # @api public
+      #
+      def self.add_keys(array, keys)
+        base = keys.inject({}) { |a, e| a.merge(e => nil) }
+        map_array(array, ->(v) { base.merge(v) })
+      end
+    end
+  end
+end

data/lib/dry/transformer/array/combine.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    module ArrayTransformations
+      class Combine
+        EMPTY_ARRAY = [].freeze
+
+        class << self
+          def combine(array, mappings)
+            root, nodes = array
+            return EMPTY_ARRAY if root.nil?
+            return root if nodes.nil?
+
+            groups = group_nodes(nodes, mappings)
+
+            root.map do |element|
+              element.dup.tap { |copy| add_groups_to_element(copy, groups, mappings) }
+            end
+          end
+
+          private
+
+          def add_groups_to_element(element, groups, mappings)
+            groups.each_with_index do |candidates, index|
+              mapping = mappings[index]
+              resource_key = mapping[0]
+              element[resource_key] = element_candidates(element, candidates, mapping[1].keys)
+            end
+          end
+
+          def element_candidates(element, candidates, keys)
+            candidates[element_candidates_key(element, keys)] || EMPTY_ARRAY
+          end
+
+          def group_nodes(nodes, mappings)
+            nodes.each_with_index.map do |candidates, index|
+              mapping = mappings[index]
+              group_candidates(candidates, mapping)
+            end
+          end
+
+          def group_candidates(candidates, mapping)
+            nested_mapping = mapping[2]
+            candidates = combine(candidates, nested_mapping) unless nested_mapping.nil?
+            group_candidates_by_keys(candidates, mapping[1].values)
+          end
+
+          def group_candidates_by_keys(candidates, keys)
+            return candidates.group_by { |a| a.values_at(*keys) } if keys.size > 1
+
+            key = keys.first
+            candidates.group_by { |a| a[key] }
+          end
+
+          def element_candidates_key(element, keys)
+            return element.values_at(*keys) if keys.size > 1
+
+            element[keys.first]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/transformer/class.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # Transformation functions for Classes
+    #
+    # @example
+    #   require 'dry/transformer/class'
+    #
+    #   include Dry::Transformer::Helper
+    #
+    #   fn = t(:constructor_inject, Struct)
+    #
+    #   fn['User', :name, :age]
+    #   # => Struct::User
+    #
+    # @api public
+    module ClassTransformations
+      extend Registry
+
+      # Inject given arguments into the constructor of the class
+      #
+      # @example
+      #   Transproct(:constructor_inject, Struct)['User', :name, :age]
+      #   # => Struct::User
+      #
+      # @param [*Mixed] A list of arguments to inject
+      #
+      # @return [Object] An instance of the given klass
+      #
+      # @api public
+      def self.constructor_inject(*args, klass)
+        klass.new(*args)
+      end
+
+      # Set instance variables from the hash argument (key/value pairs) on the object
+      #
+      # @example
+      #   Dry::Transformer(:set_ivars, Object)[name: 'Jane', age: 25]
+      #   # => #<Object:0x007f411d06a210 @name="Jane", @age=25>
+      #
+      # @param [Object]
+      #
+      # @return [Object]
+      #
+      # @api public
+      def self.set_ivars(ivar_hash, klass)
+        object = klass.allocate
+        ivar_hash.each do |ivar_name, ivar_value|
+          object.instance_variable_set("@#{ivar_name}", ivar_value)
+        end
+        object
+      end
+    end
+  end
+end