dry-transformer 0.1.1

data/lib/dry/transformer/coercions.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Dry
+  module Transformer
+    # Coercion functions for common types
+    #
+    # @api public
+    module Coercions
+      extend Registry
+
+      TRUE_VALUES = [true, 1, '1', 'on', 't', 'true', 'y', 'yes'].freeze
+      FALSE_VALUES = [false, 0, '0', 'off', 'f', 'false', 'n', 'no', nil].freeze
+
+      BOOLEAN_MAP = Hash[
+        TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])
+      ].freeze
+
+      # Does nothing and returns a value
+      #
+      # @example
+      #   fn = Coercions[:identity]
+      #   fn[:foo] # => :foo
+      #
+      # @param [Object] value
+      #
+      # @return [Object]
+      #
+      # @api public
+      def self.identity(value = nil)
+        value
+      end
+
+      # Coerce value into a string
+      #
+      # @example
+      #   Dry::Transformer(:to_string)[1]
+      #   # => "1"
+      #
+      # @param [Object] value The input value
+      #
+      # @return [String]
+      #
+      # @api public
+      def self.to_string(value)
+        value.to_s
+      end
+
+      # Coerce value into a symbol
+      #
+      # @example
+      #   Dry::Transformer(:to_symbol)['foo']
+      #   # => :foo
+      #
+      # @param [#to_s] value The input value
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def self.to_symbol(value)
+        value.to_s.to_sym
+      end
+
+      # Coerce value into a integer
+      #
+      # @example
+      #   Dry::Transformer(:to_integer)['1']
+      #   # => 1
+      #
+      # @param [Object] value The input value
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def self.to_integer(value)
+        value.to_i
+      end
+
+      # Coerce value into a float
+      #
+      # @example
+      #   Dry::Transformer(:to_float)['1.2']
+      #   # => 1.2
+      #
+      # @param [Object] value The input value
+      #
+      # @return [Float]
+      #
+      # @api public
+      def self.to_float(value)
+        value.to_f
+      end
+
+      # Coerce value into a decimal
+      #
+      # @example
+      #   Dry::Transformer(:to_decimal)[1.2]
+      #   # => #<BigDecimal:7fca32acea50,'0.12E1',18(36)>
+      #
+      # @param [Object] value The input value
+      #
+      # @return [Decimal]
+      #
+      # @api public
+      def self.to_decimal(value)
+        value.to_d
+      end
+
+      # Coerce value into a boolean
+      #
+      # @example
+      #   Dry::Transformer(:to_boolean)['true']
+      #   # => true
+      #   Dry::Transformer(:to_boolean)['f']
+      #   # => false
+      #
+      # @param [Object] value The input value
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @api public
+      def self.to_boolean(value)
+        BOOLEAN_MAP.fetch(value)
+      end
+
+      # Coerce value into a date
+      #
+      # @example
+      #   Dry::Transformer(:to_date)['2015-04-14']
+      #   # => #<Date: 2015-04-14 ((2457127j,0s,0n),+0s,2299161j)>
+      #
+      # @param [Object] value The input value
+      #
+      # @return [Date]
+      #
+      # @api public
+      def self.to_date(value)
+        Date.parse(value)
+      end
+
+      # Coerce value into a time
+      #
+      # @example
+      #   Dry::Transformer(:to_time)['2015-04-14 12:01:45']
+      #   # => 2015-04-14 12:01:45 +0200
+      #
+      # @param [Object] value The input value
+      #
+      # @return [Time]
+      #
+      # @api public
+      def self.to_time(value)
+        Time.parse(value)
+      end
+
+      # Coerce value into a datetime
+      #
+      # @example
+      #   Dry::Transformer(:to_datetime)['2015-04-14 12:01:45']
+      #   # => #<DateTime: 2015-04-14T12:01:45+00:00 ((2457127j,43305s,0n),+0s,2299161j)>
+      #
+      # @param [Object] value The input value
+      #
+      # @return [DateTime]
+      #
+      # @api public
+      def self.to_datetime(value)
+        DateTime.parse(value)
+      end
+
+      # Coerce value into an array containing tuples only
+      #
+      # If the source is not an array, or doesn't contain a tuple, returns
+      # an array with one empty tuple
+      #
+      # @example
+      #   Dry::Transformer(:to_tuples)[:foo]                  # => [{}]
+      #   Dry::Transformer(:to_tuples)[[]]                    # => [{}]
+      #   Dry::Transformer(:to_tuples)[[{ foo: :FOO, :bar }]] # => [{ foo: :FOO }]
+      #
+      # @param [Object] value
+      #
+      # @return [Array<Hash>]
+      #
+      def self.to_tuples(value)
+        array = value.is_a?(Array) ? Array[*value] : [{}]
+        array.select! { |item| item.is_a?(Hash) }
+        array.any? ? array : [{}]
+      end
+    end
+  end
+end

data/lib/dry/transformer/compiler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # @api private
+    class Compiler
+      InvalidFunctionNameError = Class.new(StandardError)
+
+      attr_reader :registry, :transformer
+
+      def initialize(registry, transformer = nil)
+        @registry = registry
+        @transformer = transformer
+      end
+
+      def call(ast)
+        ast.map(&method(:visit)).reduce(:>>)
+      end
+
+      def visit(node)
+        id, *rest = node
+        public_send(:"visit_#{id}", *rest)
+      end
+
+      def visit_fn(node)
+        name, rest = node
+        args = rest.map { |arg| visit(arg) }
+
+        if registry.contain?(name)
+          registry[name, *args]
+        elsif transformer.respond_to?(name)
+          Function.new(transformer.method(name), name: name, args: args)
+        else
+          raise InvalidFunctionNameError, "function name +#{name}+ is not valid"
+        end
+      end
+
+      def visit_arg(arg)
+        arg
+      end
+
+      def visit_t(node)
+        call(node)
+      end
+    end
+  end
+end

data/lib/dry/transformer/composite.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # Composition of two functions
+    #
+    # @api private
+    class Composite
+      # @return [Proc]
+      #
+      # @api private
+      attr_reader :left
+
+      # @return [Proc]
+      #
+      # @api private
+      attr_reader :right
+
+      # @api private
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      # Call right side with the result from the left side
+      #
+      # @param [Object] value The input value
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(value)
+        right.call(left.call(value))
+      end
+      alias_method :[], :call
+
+      # @see Function#compose
+      #
+      # @api public
+      def compose(other)
+        self.class.new(self, other)
+      end
+      alias_method :+, :compose
+      alias_method :>>, :compose
+
+      # @see Function#to_ast
+      #
+      # @api public
+      def to_ast
+        left.to_ast << right.to_ast
+      end
+    end
+  end
+end

data/lib/dry/transformer/conditional.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    # Conditional transformation functions
+    #
+    # @example
+    #   require 'dry/transformer/conditional'
+    #
+    #   include Dry::Transformer::Helper
+    #
+    #   fn = t(:guard, -> s { s.is_a?(::String) }, -> s { s.to_sym })
+    #
+    #   [fn[2], fn['Jane']]
+    #   # => [2, :Jane]
+    #
+    # @api public
+    module Conditional
+      extend Registry
+
+      # Negates the result of transformation
+      #
+      # @example
+      #   fn = Conditional[:not, -> value { value.is_a? ::String }]
+      #   fn[:foo]  # => true
+      #   fn["foo"] # => false
+      #
+      # @param [Object] value
+      # @param [Proc] fn
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def self.not(value, fn)
+        !fn[value]
+      end
+
+      # Apply the transformation function to subject if the predicate returns true, or return un-modified
+      #
+      # @example
+      #   [2, 'Jane'].map do |subject|
+      #     Dry::Transformer(:guard, -> s { s.is_a?(::String) }, -> s { s.to_sym })[subject]
+      #   end
+      #   # => [2, :Jane]
+      #
+      # @param [Mixed]
+      #
+      # @return [Mixed]
+      #
+      # @api public
+      def self.guard(value, predicate, fn)
+        predicate[value] ? fn[value] : value
+      end
+
+      # Calls a function when type-check passes
+      #
+      # @example
+      #   fn = Dry::Transformer(:is, Array, -> arr { arr.map(&:upcase) })
+      #   fn.call(['a', 'b', 'c']) # => ['A', 'B', 'C']
+      #
+      #   fn = Dry::Transformer(:is, Array, -> arr { arr.map(&:upcase) })
+      #   fn.call('foo') # => "foo"
+      #
+      # @param [Object]
+      # @param [Class]
+      # @param [Proc]
+      #
+      # @return [Object]
+      #
+      # @api public
+      def self.is(value, type, fn)
+        guard(value, -> v { v.is_a?(type) }, fn)
+      end
+    end
+  end
+end

data/lib/dry/transformer/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    Undefined = Object.new.freeze
+  end
+end

data/lib/dry/transformer/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transformer
+    Error = Class.new(StandardError)
+    FunctionAlreadyRegisteredError = Class.new(Error)
+
+    class FunctionNotFoundError < Error
+      def initialize(function, source = nil)
+        return super "No registered function #{source}[:#{function}]" if source
+
+        super "No globally registered function for #{function}"
+      end
+    end
+  end
+end

data/lib/dry/transformer/function.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/composite'
+
+module Dry
+  module Transformer
+    # Transformation proc wrapper allowing composition of multiple procs into
+    # a data-transformation pipeline.
+    #
+    # This is used by Dry::Transformer to wrap registered methods.
+    #
+    # @api private
+    class Function
+      # Wrapped proc or another composite function
+      #
+      # @return [Proc,Composed]
+      #
+      # @api private
+      attr_reader :fn
+
+      # Additional arguments that will be passed to the wrapped proc
+      #
+      # @return [Array]
+      #
+      # @api private
+      attr_reader :args
+
+      # @!attribute [r] name
+      #
+      # @return [<type] The name of the function
+      #
+      # @api public
+      attr_reader :name
+
+      # @api private
+      def initialize(fn, options = {})
+        @fn = fn
+        @args = options.fetch(:args, [])
+        @name = options.fetch(:name, fn)
+      end
+
+      # Call the wrapped proc
+      #
+      # @param [Object] value The input value
+      #
+      # @alias []
+      #
+      # @api public
+      def call(*value)
+        fn.call(*value, *args)
+      end
+      alias_method :[], :call
+
+      # Compose this function with another function or a proc
+      #
+      # @param [Proc,Function]
+      #
+      # @return [Composite]
+      #
+      # @alias :>>
+      #
+      # @api public
+      def compose(other)
+        Composite.new(self, other)
+      end
+      alias_method :+, :compose
+      alias_method :>>, :compose
+
+      # Return a new fn with curried args
+      #
+      # @return [Function]
+      #
+      # @api private
+      def with(*args)
+        self.class.new(fn, name: name, args: args)
+      end
+
+      # @api public
+      def ==(other)
+        return false unless other.instance_of?(self.class)
+
+        [fn, name, args] == [other.fn, other.name, other.args]
+      end
+      alias_method :eql?, :==
+
+      # Return a simple AST representation of this function
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ast
+        args_ast = args.map { |arg| arg.respond_to?(:to_ast) ? arg.to_ast : arg }
+        [name, args_ast]
+      end
+
+      # Converts a transproc to a simple proc
+      #
+      # @return [Proc]
+      #
+      def to_proc
+        if !args.empty?
+          proc { |*value| fn.call(*value, *args) }
+        else
+          fn.to_proc
+        end
+      end
+    end
+  end
+end