transproc 1.0.0 → 1.1.1

data/lib/transproc/array/combine.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Transproc
+  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

data/lib/transproc/class.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   # Transformation functions for Classes
   #

data/lib/transproc/coercions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'time'
 require 'bigdecimal'

data/lib/transproc/compiler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Transproc
+  # @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

data/lib/transproc/composer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'transproc/support/deprecations'
 
 module Transproc

data/lib/transproc/composite.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   # Composition of two functions
   #

data/lib/transproc/conditional.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   # Conditional transformation functions
   #

data/lib/transproc/constants.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Transproc
+  Undefined = Object.new.freeze
+end

data/lib/transproc/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   Error = Class.new(StandardError)
   FunctionAlreadyRegisteredError = Class.new(Error)

data/lib/transproc/function.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'transproc/composite'
 
 module Transproc
@@ -85,7 +87,8 @@ module Transproc
     #
     # @api public
     def to_ast
-      [name, args]
+      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

data/lib/transproc/functions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   # Function container extension
   #

data/lib/transproc/hash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'transproc/coercions'
 
 module Transproc
@@ -17,20 +19,28 @@ module Transproc
   module HashTransformations
     extend Registry
 
-    # Map all keys in a hash with the provided transformation function
-    #
-    # @example
-    #   Transproc(:map_keys, -> s { s.upcase })['name' => 'Jane']
-    #   # => {"NAME" => "Jane"}
-    #
-    # @param [Hash]
-    #
-    # @return [Hash]
-    #
-    # @api public
-    def self.map_keys(source_hash, fn)
-      Hash[source_hash].tap do |hash|
-        hash.keys.each { |key| hash[fn[key]] = hash.delete(key) }
+    EMPTY_HASH = {}.freeze
+
+    if RUBY_VERSION >= '2.5'
+      # Map all keys in a hash with the provided transformation function
+      #
+      # @example
+      #   Transproc(:map_keys, -> s { s.upcase })['name' => 'Jane']
+      #   # => {"NAME" => "Jane"}
+      #
+      # @param [Hash]
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def self.map_keys(source_hash, fn)
+        Hash[source_hash].transform_keys!(&fn)
+      end
+    else
+      def self.map_keys(source_hash, fn)
+        Hash[source_hash].tap do |hash|
+          hash.keys.each { |key| hash[fn[key]] = hash.delete(key) }
+        end
       end
     end
 
@@ -94,20 +104,55 @@ module Transproc
       map_keys(hash, Coercions[:to_string].fn)
     end
 
-    # Map all values in a hash using transformation function
+    # Stringify keys in a hash recursively
     #
     # @example
-    #   Transproc(:map_values, -> v { v.upcase })[:name => 'Jane']
-    #   # => {"name" => "JANE"}
+    #   input = { :foo => "bar", :baz => [{ :one => 1 }] }
+    #
+    #   t(:deep_stringify_keys)[input]
+    #   # => { "foo" => "bar", "baz" => [{ "one" => 1 }] }
     #
     # @param [Hash]
     #
     # @return [Hash]
     #
     # @api public
-    def self.map_values(source_hash, fn)
-      Hash[source_hash].tap do |hash|
-        hash.each { |key, value| hash[key] = fn[value] }
+    def self.deep_stringify_keys(hash)
+      hash.each_with_object({}) do |(key, value), output|
+        output[key.to_s] =
+          case value
+          when Hash
+            deep_stringify_keys(value)
+          when Array
+            value.map { |item|
+              item.is_a?(Hash) ? deep_stringify_keys(item) : item
+            }
+          else
+            value
+          end
+      end
+    end
+
+    if RUBY_VERSION >= '2.4'
+      # Map all values in a hash using transformation function
+      #
+      # @example
+      #   Transproc(:map_values, -> v { v.upcase })[:name => 'Jane']
+      #   # => {"name" => "JANE"}
+      #
+      # @param [Hash]
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def self.map_values(source_hash, fn)
+        Hash[source_hash].transform_values!(&fn)
+      end
+    else
+      def self.map_values(source_hash, fn)
+        Hash[source_hash].tap do |hash|
+          hash.each { |key, value| hash[key] = fn[value] }
+        end
       end
     end
 
@@ -167,20 +212,26 @@ module Transproc
       Hash[hash].reject { |k, _| keys.include?(k) }
     end
 
-    # Accepts specified keys from a hash
-    #
-    # @example
-    #   Transproc(:accept_keys, [:name])[name: 'Jane', email: 'jane@doe.org']
-    #   # => {:name=>"Jane"}
-    #
-    # @param [Hash] hash The input hash
-    # @param [Array] keys The keys to be accepted
-    #
-    # @return [Hash]
-    #
-    # @api public
-    def self.accept_keys(hash, keys)
-      reject_keys(hash, hash.keys - keys)
+    if RUBY_VERSION >= '2.5'
+      # Accepts specified keys from a hash
+      #
+      # @example
+      #   Transproc(:accept_keys, [:name])[name: 'Jane', email: 'jane@doe.org']
+      #   # => {:name=>"Jane"}
+      #
+      # @param [Hash] hash The input hash
+      # @param [Array] keys The keys to be accepted
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def self.accept_keys(hash, keys)
+        Hash[hash].slice(*keys)
+      end
+    else
+      def self.accept_keys(hash, keys)
+        reject_keys(hash, hash.keys - keys)
+      end
     end
 
     # Map a key in a hash with the provided transformation function
@@ -209,18 +260,26 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def self.nest(source_hash, root, keys)
-      nest_keys = source_hash.keys & keys
+    def self.nest(hash, root, keys)
+      child = {}
 
-      if !nest_keys.empty?
-        hash = Hash[source_hash]
-        child = Hash[nest_keys.zip(nest_keys.map { |key| hash.delete(key) })]
-        old_nest = hash[root]
-        new_nest = old_nest.is_a?(Hash) ? old_nest.merge(child) : child
-        hash.merge(root => new_nest)
+      keys.each do |key|
+        child[key] = hash[key] if hash.key?(key)
+      end
+
+      output = Hash[hash]
+
+      child.each_key { |key| output.delete(key) }
+
+      old_root = hash[root]
+
+      if old_root.is_a?(Hash)
+        output[root] = old_root.merge(child)
       else
-        source_hash.merge(root => {})
+        output[root] = child
       end
+
+      output
     end
 
     # Collapse a nested hash from a specified key
@@ -239,8 +298,9 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def self.unwrap(source_hash, root, selected = nil, prefix: false)
+    def self.unwrap(source_hash, root, selected = nil, options = EMPTY_HASH)
       return source_hash unless source_hash[root]
+      options, selected = selected, nil if options.empty? && selected.is_a?(::Hash)
 
       add_prefix = ->(key) do
         combined = [root, key].join('_')
@@ -251,7 +311,7 @@ module Transproc
         nested_hash = hash[root]
         keys = nested_hash.keys
         keys &= selected if selected
-        new_keys = prefix ? keys.map(&add_prefix) : keys
+        new_keys = options[:prefix] ? keys.map(&add_prefix) : keys
 
         hash.update(Hash[new_keys.zip(keys.map { |key| nested_hash.delete(key) })])
         hash.delete(root) if nested_hash.empty?

data/lib/transproc/proc.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   # Transformation functions for Procs
   #

data/lib/transproc/recursion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'transproc/conditional'
 
 module Transproc

data/lib/transproc/registry.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Transproc
   # Container to define transproc functions in, and access them via `[]` method
@@ -46,8 +47,9 @@ module Transproc
     #
     def [](fn, *args)
       fetched = fetch(fn)
-      return fetched if already_wrapped?(fetched)
-      Function.new(fetched, args: args, name: fn)
+
+      return Function.new(fetched, args: args, name: fn) unless already_wrapped?(fetched)
+      args.empty? ? fetched : fetched.with(*args)
     end
     alias_method :t, :[]
 

data/lib/transproc/store.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Transproc
   # Immutable collection of named procedures from external modules

data/lib/transproc/support/deprecations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Transproc
   module Deprecations
     def self.announce(name, msg)

data/lib/transproc/transformer.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'transproc/transformer/class_interface'
+require 'transproc/transformer/deprecated/class_interface'
 
 module Transproc
   # Transfomer class for defining transprocs with a class DSL.
@@ -45,6 +48,9 @@ module Transproc
   # @api public
   class Transformer
     extend ClassInterface
+    extend Deprecated::ClassInterface
+
+    attr_reader :transproc
 
     # Execute the transformation pipeline with the given input.
     #
@@ -63,7 +69,7 @@ module Transproc
     #
     # @api public
     def call(input)
-      self.class.transproc.call(input)
+      transproc.call(input)
     end
   end
 end