dry-transformer 0.1.0

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

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