dry-transformer 0.1.1

data/lib/dry/transformer/pipe.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/pipe/class_interface'
+
+module Dry
+  module Transformer
+    # Pipe class for defining transprocs with a class DSL.
+    #
+    # @example
+    #   require 'anima'
+    #   require 'dry/transformer/all'
+    #
+    #   class User
+    #     include Anima.new(:name, :address)
+    #   end
+    #
+    #   class Address
+    #     include Anima.new(:city, :street, :zipcode)
+    #   end
+    #
+    #   class UsersMapper < Dry::Transformer::Pipe
+    #     map_array do
+    #       symbolize_keys
+    #       rename_keys user_name: :name
+    #       nest :address, %i(city street zipcode)
+    #       map_value :address do
+    #         constructor_inject Address
+    #       end
+    #       constructor_inject User
+    #     end
+    #   end
+    #
+    #   UsersMapper.new.call(
+    #     [
+    #       { 'user_name' => 'Jane',
+    #         'city' => 'NYC',
+    #         'street' => 'Street 1',
+    #         'zipcode' => '123'
+    #       }
+    #     ]
+    #   )
+    #   # => [
+    #     #<User
+    #       name="Jane"
+    #       address=#<Address city="NYC" street="Street 1" zipcode="123">>
+    #   ]
+    #
+    # @api public
+    class Pipe
+      extend ClassInterface
+
+      attr_reader :transproc
+
+      # Execute the transformation pipeline with the given input.
+      #
+      # @example
+      #
+      #   class SymbolizeKeys < Dry::Transformer
+      #     symbolize_keys
+      #   end
+      #
+      #   SymbolizeKeys.new.call('name' => 'Jane')
+      #   # => {:name=>"Jane"}
+      #
+      # @param [mixed] input The input to pass to the pipeline
+      #
+      # @return [mixed] output The output returned from the pipeline
+      #
+      # @api public
+      def call(input)
+        transproc.call(input)
+      end
+    end
+  end
+end

data/lib/dry/transformer/pipe/class_interface.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/pipe/dsl'
+
+module Dry
+  module Transformer
+    class Pipe
+      # @api public
+      module ClassInterface
+        # @api private
+        attr_reader :dsl
+
+        # Return a base Dry::Transformer class with the
+        # container configured to the passed argument.
+        #
+        # @example
+        #
+        #   class MyTransformer < Dry::Transformer[Transproc]
+        #   end
+        #
+        # @param [Transproc::Registry] container
+        #   The container to resolve transprocs from
+        #
+        # @return [subclass of Dry::Transformer]
+        #
+        # @api public
+        def [](container)
+          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.
+        #
+        # @example
+        #
+        #   # Setter
+        #   Dry::Transformer.container(Transproc)
+        #   # => Transproc
+        #
+        #   # Getter
+        #   Dry::Transformer.container
+        #   # => Transproc
+        #
+        # @param [Transproc::Registry] container
+        #   The container to resolve transprocs from
+        #
+        # @return [Transproc::Registry]
+        #
+        # @api private
+        def container(container = Undefined)
+          if container.equal?(Undefined)
+            @container ||= Module.new.extend(Dry::Transformer::Registry)
+          else
+            @container = container
+          end
+        end
+
+        # @api public
+        def import(*args)
+          container.import(*args)
+        end
+
+        # @api public
+        def define!(&block)
+          @dsl ||= DSL.new(container)
+          @dsl.instance_eval(&block)
+          self
+        end
+
+        # @api public
+        def new(*)
+          super.tap do |transformer|
+            transformer.instance_variable_set('@transproc', dsl.(transformer)) if dsl
+          end
+        end
+        ruby2_keywords(:new) if respond_to?(:ruby2_keywords, true)
+
+        # Get a transformation from the container,
+        # without adding it to the transformation pipeline
+        #
+        # @example
+        #
+        #   class Stringify < Dry::Transformer
+        #     map_values t(:to_string)
+        #   end
+        #
+        #   Stringify.new.call(a: 1, b: 2)
+        #   # => {a: '1', b: '2'}
+        #
+        # @param [Proc, Symbol] fn
+        #   A proc, a name of the module's own function, or a name of imported
+        #   procedure from another module
+        # @param [Object, Array] args
+        #   Args to be carried by the transproc
+        #
+        # @return [Transproc::Function]
+        #
+        # @api public
+        def t(fn, *args)
+          container[fn, *args]
+        end
+      end
+    end
+  end
+end

data/lib/dry/transformer/pipe/dsl.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/compiler'
+
+module Dry
+  module Transformer
+    class Pipe
+      # @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 public
+        def t(name, *args)
+          container[name, *args]
+        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
+end

data/lib/dry/transformer/proc.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # Transformation functions for Procs
+    #
+    # @example
+    #   require 'ostruct'
+    #   require 'dry/transformer/proc'
+    #
+    #   include Dry::Transformer::Helper
+    #
+    #   fn = t(
+    #     :map_value,
+    #     'foo_bar',
+    #     t(:bind, OpenStruct.new(prefix: 'foo'), -> s { [prefix, s].join('_') })
+    #   )
+    #
+    #   fn["foo_bar" => "bar"]
+    #   # => {"foo_bar" => "foo_bar"}
+    #
+    # @api public
+    module ProcTransformations
+      extend Registry
+
+      # Change the binding for the given function
+      #
+      # @example
+      #   Dry::Transformer(
+      #     :bind,
+      #     OpenStruct.new(prefix: 'foo'),
+      #     -> s { [prefix, s].join('_') }
+      #   )['bar']
+      #   # => "foo_bar"
+      #
+      # @param [Proc]
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def self.bind(value, binding, fn)
+        binding.instance_exec(value, &fn)
+      end
+    end
+  end
+end

data/lib/dry/transformer/recursion.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/conditional'
+
+module Dry
+  module Transformer
+    # Recursive transformation functions
+    #
+    # @example
+    #   require 'dry/transformer/recursion'
+    #
+    #   include Dry::Transformer::Helper
+    #
+    #   fn = t(:hash_recursion, t(:symbolize_keys))
+    #
+    #   fn["name" => "Jane", "address" => { "street" => "Street 1" }]
+    #   # => {:name=>"Jane", :address=>{:street=>"Street 1"}}
+    #
+    # @api public
+    module Recursion
+      extend Registry
+
+      IF_ENUMERABLE = -> fn { Conditional[:is, Enumerable, fn] }
+
+      IF_ARRAY = -> fn { Conditional[:is, Array, fn] }
+
+      IF_HASH = -> fn { Conditional[:is, Hash, fn] }
+
+      # Recursively apply the provided transformation function to an enumerable
+      #
+      # @example
+      #   Dry::Transformer(:recursion, Dry::Transformer(:is, ::Hash, Dry::Transformer(:symbolize_keys)))[
+      #     {
+      #       'id' => 1,
+      #       'name' => 'Jane',
+      #       'tasks' => [
+      #         { 'id' => 1, 'description' => 'Write some code' },
+      #         { 'id' => 2, 'description' => 'Write some more code' }
+      #       ]
+      #     }
+      #   ]
+      #   => {
+      #        :id=>1,
+      #        :name=>"Jane",
+      #        :tasks=>[
+      #          {:id=>1, :description=>"Write some code"},
+      #          {:id=>2, :description=>"Write some more code"}
+      #        ]
+      #      }
+      #
+      # @param [Enumerable]
+      #
+      # @return [Enumerable]
+      #
+      # @api public
+      def self.recursion(value, fn)
+        result = fn[value]
+        guarded = IF_ENUMERABLE[-> v { recursion(v, fn) }]
+
+        case result
+        when ::Hash
+          result.keys.each do |key|
+            result[key] = guarded[result.delete(key)]
+          end
+        when ::Array
+          result.map! do |item|
+            guarded[item]
+          end
+        end
+
+        result
+      end
+
+      # Recursively apply the provided transformation function to an array
+      #
+      # @example
+      #   Dry::Transformer(:array_recursion, -> s { s.compact })[
+      #     [['Joe', 'Jane', nil], ['Smith', 'Doe', nil]]
+      #   ]
+      #   # =>  [["Joe", "Jane"], ["Smith", "Doe"]]
+      #
+      # @param [Array]
+      #
+      # @return [Array]
+      #
+      # @api public
+      def self.array_recursion(value, fn)
+        result = fn[value]
+        guarded = IF_ARRAY[-> v { array_recursion(v, fn) }]
+
+        result.map! do |item|
+          guarded[item]
+        end
+      end
+
+      # Recursively apply the provided transformation function to a hash
+      #
+      # @example
+      #   Dry::Transformer(:hash_recursion, Dry::Transformer(:symbolize_keys))[
+      #     ["name" => "Jane", "address" => { "street" => "Street 1", "zipcode" => "123" }]
+      #   ]
+      #   # =>  {:name=>"Jane", :address=>{:street=>"Street 1", :zipcode=>"123"}}
+      #
+      # @param [Hash]
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def self.hash_recursion(value, fn)
+        result = fn[value]
+        guarded = IF_HASH[-> v { hash_recursion(v, fn) }]
+
+        result.keys.each do |key|
+          result[key] = guarded[result.delete(key)]
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/dry/transformer/registry.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # Container to define transproc functions in, and access them via `[]` method
+    # from the outside of the module
+    #
+    # @example
+    #   module FooMethods
+    #     extend Dry::Transformer::Registry
+    #
+    #     def self.foo(name, prefix)
+    #       [prefix, '_', name].join
+    #     end
+    #   end
+    #
+    #   fn = FooMethods[:foo, 'baz']
+    #   fn['qux'] # => 'qux_baz'
+    #
+    #   module BarMethods
+    #     extend FooMethods
+    #
+    #     def self.bar(*args)
+    #       foo(*args).upcase
+    #     end
+    #   end
+    #
+    #   fn = BarMethods[:foo, 'baz']
+    #   fn['qux'] # => 'qux_baz'
+    #
+    #   fn = BarMethods[:bar, 'baz']
+    #   fn['qux'] # => 'QUX_BAZ'
+    #
+    # @api public
+    module Registry
+      # Builds the transformation
+      #
+      # @param [Proc, Symbol] fn
+      #   A proc, a name of the module's own function, or a name of imported
+      #   procedure from another module
+      # @param [Object, Array] args
+      #   Args to be carried by the transproc
+      #
+      # @return [Dry::Transformer::Function]
+      #
+      # @alias :t
+      #
+      def [](fn, *args)
+        fetched = fetch(fn)
+
+        return Function.new(fetched, args: args, name: fn) unless already_wrapped?(fetched)
+
+        args.empty? ? fetched : fetched.with(*args)
+      end
+      alias_method :t, :[]
+
+      # Returns wether the registry contains such transformation by its key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Boolean]
+      #
+      def contain?(key)
+        respond_to?(key) || store.contain?(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)
+        if contain?(name)
+          raise FunctionAlreadyRegisteredError, "Function #{name} is already defined"
+        end
+
+        @store = store.register(name, fn, &block)
+        self
+      end
+
+      # Imports either a method (converted to a proc) from another module, or
+      # all methods from that module.
+      #
+      # If the external module is a registry, looks for its imports too.
+      #
+      # @overload import(source)
+      #   Loads all methods from the source object
+      #
+      #   @param [Object] source
+      #
+      # @overload import(*names, **options)
+      #   Loads selected methods from the source object
+      #
+      #   @param [Array<Symbol>] names
+      #   @param [Hash] options
+      #   @options options [Object] :from The source object
+      #
+      # @overload import(name, **options)
+      #   Loads selected methods from the source object
+      #
+      #   @param [Symbol] name
+      #   @param [Hash] options
+      #   @options options [Object] :from The source object
+      #   @options options [Object] :as The new name for the transformation
+      #
+      # @return [itself] self
+      #
+      # @alias :import
+      #
+      def import(*args)
+        @store = store.import(*args)
+        self
+      end
+      alias_method :uses, :import
+
+      # The store of procedures imported from external modules
+      #
+      # @return [Dry::Transformer::Store]
+      #
+      def store
+        @store ||= Store.new
+      end
+
+      # Gets the procedure for creating a transproc
+      #
+      # @param [#call, Symbol] fn
+      #   Either the procedure, or the name of the method of the current module,
+      #   or the registered key of imported procedure in a store.
+      #
+      # @return [#call]
+      #
+      def fetch(fn)
+        return fn unless fn.instance_of? Symbol
+
+        respond_to?(fn) ? method(fn) : store.fetch(fn)
+      rescue StandardError
+        raise FunctionNotFoundError.new(fn, self)
+      end
+
+      private
+
+      # @api private
+      def already_wrapped?(func)
+        func.is_a?(Dry::Transformer::Function) || func.is_a?(Dry::Transformer::Composite)
+      end
+    end
+  end
+end