transproc 0.4.2 → 1.0.0

data/lib/transproc/conditional.rb

@@ -68,9 +68,5 @@ module Transproc
     def self.is(value, type, fn)
       guard(value, -> v { v.is_a?(type) }, fn)
     end
-
-    # @deprecated Register methods globally
-    (methods - Registry.methods - Registry.instance_methods)
-      .each { |name| Transproc.register name, t(name) }
   end
 end

data/lib/transproc/hash.rb

@@ -28,18 +28,10 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def self.map_keys(hash, fn)
-      map_keys!(Hash[hash], fn)
-    end
-
-    # Same as `:map_keys` but mutates the hash
-    #
-    # @see HashTransformations.map_keys
-    #
-    # @api public
-    def self.map_keys!(hash, fn)
-      hash.keys.each { |key| hash[fn[key]] = hash.delete(key) }
-      hash
+    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
 
     # Symbolize all keys in a hash
@@ -54,16 +46,7 @@ module Transproc
     #
     # @api public
     def self.symbolize_keys(hash)
-      symbolize_keys!(Hash[hash])
-    end
-
-    # Same as `:symbolize_keys` but mutates the hash
-    #
-    # @see HashTransformations.symbolize_keys!
-    #
-    # @api public
-    def self.symbolize_keys!(hash)
-      map_keys!(hash, Coercions[:to_symbol].fn)
+      map_keys(hash, Coercions[:to_symbol].fn)
     end
 
     # Symbolize keys in a hash recursively
@@ -108,16 +91,7 @@ module Transproc
     #
     # @api public
     def self.stringify_keys(hash)
-      stringify_keys!(Hash[hash])
-    end
-
-    # Same as `:stringify_keys` but mutates the hash
-    #
-    # @see HashTransformations.stringify_keys
-    #
-    # @api public
-    def self.stringify_keys!(hash)
-      map_keys!(hash, Coercions[:to_string].fn)
+      map_keys(hash, Coercions[:to_string].fn)
     end
 
     # Map all values in a hash using transformation function
@@ -131,22 +105,10 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def self.map_values(hash, fn)
-      map_values!(Hash[hash], fn)
-    end
-
-    # Same as `:map_values` but mutates the hash
-    #
-    # @see HashTransformations.map_values
-    #
-    # @param [Hash]
-    #
-    # @return [Hash]
-    #
-    # @api public
-    def self.map_values!(hash, fn)
-      hash.each { |key, value| hash[key] = fn[value] }
-      hash
+    def self.map_values(source_hash, fn)
+      Hash[source_hash].tap do |hash|
+        hash.each { |key, value| hash[key] = fn[value] }
+      end
     end
 
     # Rename all keys in a hash using provided mapping hash
@@ -155,24 +117,16 @@ module Transproc
     #   Transproc(:rename_keys, user_name: :name)[user_name: 'Jane']
     #   # => {:name => "Jane"}
     #
-    # @param [Hash] hash The input hash
+    # @param [Hash] source_hash The input hash
     # @param [Hash] mapping The key-rename mapping
     #
     # @return [Hash]
     #
     # @api public
-    def self.rename_keys(hash, mapping)
-      rename_keys!(Hash[hash], mapping)
-    end
-
-    # Same as `:rename_keys` but mutates the hash
-    #
-    # @see HashTransformations.rename_keys
-    #
-    # @api public
-    def self.rename_keys!(hash, mapping)
-      mapping.each { |k, v| hash[v] = hash.delete(k) if hash.has_key?(k) }
-      hash
+    def self.rename_keys(source_hash, mapping)
+      Hash[source_hash].tap do |hash|
+        mapping.each { |k, v| hash[v] = hash.delete(k) if hash.key?(k) }
+      end
     end
 
     # Copy all keys in a hash using provided mapping hash
@@ -181,28 +135,20 @@ module Transproc
     #   Transproc(:copy_keys, user_name: :name)[user_name: 'Jane']
     #   # => {:user_name => "Jane", :name => "Jane"}
     #
-    # @param [Hash] hash The input hash
+    # @param [Hash] source_hash The input hash
     # @param [Hash] mapping The key-copy mapping
     #
     # @return [Hash]
     #
     # @api public
-    def self.copy_keys(hash, mapping)
-      copy_keys!(Hash[hash], mapping)
-    end
-
-    # Same as `:copy_keys` but mutates the hash
-    #
-    # @see HashTransformations.copy_keys
-    #
-    # @api public
-    def self.copy_keys!(hash, mapping)
-      mapping.each do |original_key, new_keys|
-        [*new_keys].each do |new_key|
-          hash[new_key] = hash[original_key]
+    def self.copy_keys(source_hash, mapping)
+      Hash[source_hash].tap do |hash|
+        mapping.each do |original_key, new_keys|
+          [*new_keys].each do |new_key|
+            hash[new_key] = hash[original_key]
+          end
         end
       end
-      hash
     end
 
     # Rejects specified keys from a hash
@@ -218,16 +164,7 @@ module Transproc
     #
     # @api public
     def self.reject_keys(hash, keys)
-      reject_keys!(Hash[hash], keys)
-    end
-
-    # Same as `:reject_keys` but mutates the hash
-    #
-    # @see HashTransformations.reject_keys
-    #
-    # @api public
-    def self.reject_keys!(hash, keys)
-      hash.reject { |k, _| keys.include?(k) }
+      Hash[hash].reject { |k, _| keys.include?(k) }
     end
 
     # Accepts specified keys from a hash
@@ -243,16 +180,7 @@ module Transproc
     #
     # @api public
     def self.accept_keys(hash, keys)
-      accept_keys!(Hash[hash], keys)
-    end
-
-    # Same as `:accept_keys` but mutates the hash
-    #
-    # @see HashTransformations.accept
-    #
-    # @api public
-    def self.accept_keys!(hash, keys)
-      reject_keys!(hash, hash.keys - keys)
+      reject_keys(hash, hash.keys - keys)
     end
 
     # Map a key in a hash with the provided transformation function
@@ -270,15 +198,6 @@ module Transproc
       hash.merge(key => fn[hash[key]])
     end
 
-    # Same as `:map_value` but mutates the hash
-    #
-    # @see HashTransformations.map_value
-    #
-    # @api public
-    def self.map_value!(hash, key, fn)
-      hash.update(key => fn[hash[key]])
-    end
-
     # Nest values from specified keys under a new key
     #
     # @example
@@ -290,25 +209,17 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def self.nest(hash, key, keys)
-      nest!(Hash[hash], key, keys)
-    end
-
-    # Same as `:nest` but mutates the hash
-    #
-    # @see HashTransformations.nest
-    #
-    # @api public
-    def self.nest!(hash, root, keys)
-      nest_keys = hash.keys & keys
+    def self.nest(source_hash, root, keys)
+      nest_keys = source_hash.keys & keys
 
-      if nest_keys.size > 0
+      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.update(root => new_nest)
+        hash.merge(root => new_nest)
       else
-        hash.update(root => {})
+        source_hash.merge(root => {})
       end
     end
 
@@ -318,9 +229,9 @@ module Transproc
     #   Transproc(:unwrap, :address, [:street, :zipcode])[address: { street: 'Street', zipcode: '123' }]
     #   # => {street: "Street", zipcode: "123"}
     #
-    # @param [Hash] hash
+    # @param [Hash] source_hash
     # @param [Mixed] root The root key to unwrap values from
-    # @param [Array] keys The keys that should be unwrapped (optional)
+    # @param [Array] selected The keys that should be unwrapped (optional)
     # @param [Hash] options hash of options (optional)
     # @option options [Boolean] :prefix if true, unwrapped keys will be prefixed
     #                           with the root key followed by an underscore (_)
@@ -328,37 +239,23 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def self.unwrap(hash, root, keys = nil, prefix: false)
-      copy = Hash[hash].merge(root => Hash[hash[root]])
-      unwrap!(copy, root, keys, prefix: prefix)
-    end
+    def self.unwrap(source_hash, root, selected = nil, prefix: false)
+      return source_hash unless source_hash[root]
 
-    # Same as `:unwrap` but mutates the hash
-    #
-    # @see HashTransformations.unwrap
-    #
-    # @api public
-    def self.unwrap!(hash, root, selected = nil, prefix: false)
-      if nested_hash = hash[root]
+      add_prefix = ->(key) do
+        combined = [root, key].join('_')
+        root.is_a?(::Symbol) ? combined.to_sym : combined
+      end
+
+      Hash[source_hash].merge(root => Hash[source_hash[root]]).tap do |hash|
+        nested_hash = hash[root]
         keys = nested_hash.keys
         keys &= selected if selected
-        new_keys = if prefix
-          keys.map do |key|
-            if root.is_a?(::Symbol)
-              [root, key].join('_').to_sym
-            else
-              [root, key].join('_')
-            end
-          end
-        else
-          keys
-        end
+        new_keys = 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?
       end
-
-      hash
     end
 
     # Folds array of tuples to array of values from a specified key
@@ -381,16 +278,7 @@ module Transproc
     #
     # @api public
     def self.fold(hash, key, tuple_key)
-      fold!(Hash[hash], key, tuple_key)
-    end
-
-    # Same as `:fold` but mutates the hash
-    #
-    # @see HashTransformations.fold
-    #
-    # @api public
-    def self.fold!(hash, key, tuple_key)
-      hash.update(key => ArrayTransformations.extract_key(hash[key], tuple_key))
+      hash.merge(key => ArrayTransformations.extract_key(hash[key], tuple_key))
     end
 
     # Splits hash to array by all values from a specified key
@@ -502,9 +390,5 @@ module Transproc
         end
       end
     end
-
-    # @deprecated Register methods globally
-    (methods - Registry.instance_methods - Registry.methods)
-      .each { |name| Transproc.register name, t(name) }
   end
 end

data/lib/transproc/proc.rb

@@ -38,9 +38,5 @@ module Transproc
     def self.bind(value, binding, fn)
       binding.instance_exec(value, &fn)
     end
-
-    # @deprecated Register methods globally
-    (methods - Registry.instance_methods - Registry.methods)
-      .each { |name| Transproc.register name, t(name) }
   end
 end

data/lib/transproc/recursion.rb

@@ -113,9 +113,5 @@ module Transproc
 
       result
     end
-
-    # @deprecated Register methods globally
-    (methods - Registry.methods - Registry.instance_methods)
-      .each { |name| Transproc.register name, t(name) }
   end
 end

data/lib/transproc/registry.rb

@@ -45,10 +45,37 @@ module Transproc
     # @alias :t
     #
     def [](fn, *args)
-      Function.new(fetch(fn), args: args, name: fn)
+      fetched = fetch(fn)
+      return fetched if already_wrapped?(fetched)
+      Function.new(fetched, args: args, name: fn)
     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.
     #
@@ -106,5 +133,12 @@ module Transproc
     rescue
       raise FunctionNotFoundError.new(fn, self)
     end
+
+    private
+
+    # @api private
+    def already_wrapped?(func)
+      func.is_a?(Transproc::Function) || func.is_a?(Transproc::Composite)
+    end
   end
 end

data/lib/transproc/store.rb

@@ -33,7 +33,28 @@ module Transproc
     # @return [Proc]
     #
     def fetch(key)
-      methods.fetch(key.to_sym)
+      methods.fetch(key)
+    end
+
+    # Returns wether the collection contains such procedure by its key
+    #
+    # @param [Symbol] key
+    #
+    # @return [Boolean]
+    #
+    def contain?(key)
+      methods.key?(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)
+      self.class.new(methods.merge(name => fn || block))
     end
 
     # Imports proc(s) to the collection from another module

data/lib/transproc/transformer/class_interface.rb

@@ -24,7 +24,7 @@ module Transproc
 
       # @api private
       def inherited(subclass)
-        subclass.container(container)
+        subclass.container(@container) if defined?(@container)
       end
 
       # Get or set the container to resolve transprocs from.
@@ -47,24 +47,70 @@ module Transproc
       # @api private
       def container(container = ::Transproc::Undefined)
         if container == ::Transproc::Undefined
+          ensure_container_presence!
           @container
         else
           @container = container
         end
       end
 
+      # Define an anonymous transproc derived from given Transformer
+      # Evaluates block with transformations and returns initialized transproc.
+      # Does not mutate original Transformer
+      #
+      # @example
+      #
+      #   class MyTransformer < Transproc::Transformer[MyContainer]
+      #   end
+      #
+      #   transproc = MyTransformer.define do
+      #     map_values t(:to_string)
+      #   end
+      #   transproc.call(a: 1, b: 2)
+      #   # => {a: '1', b: '2'}
+      #
+      # @yield Block allowing to define transformations. The same as class level DSL
+      #
+      # @return [Function] Composed transproc
+      #
+      # @api public
+      def define(&block)
+        return transproc unless block_given?
+
+        Class.new(self).tap { |klass| klass.instance_eval(&block) }.transproc
+      end
+      alias build define
+
+      # Get a transformation from the container,
+      # without adding it to the transformation pipeline
+      #
+      # @example
+      #
+      #   class Stringify < Transproc::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
+
       # @api private
       def method_missing(method, *args, &block)
-        if container.functions.has_key?(method)
-          if block_given?
-            transformations << container[
-              method,
-              *args,
-              create(container, &block).transproc
-            ]
-          else
-            transformations << container[method, *args]
-          end
+        if container.contain?(method)
+          args.push(define(&block)) if block_given?
+          transformations << t(method, *args)
         else
           super
         end
@@ -72,7 +118,7 @@ module Transproc
 
       # @api private
       def respond_to_missing?(method, _include_private = false)
-        container.functions.has_key?(method) || super
+        container.contain?(method) || super
       end
 
       # @api private
@@ -81,6 +127,7 @@ module Transproc
       end
 
       private
+
       # An array containing the transformation pipeline
       #
       # @api private
@@ -88,14 +135,11 @@ module Transproc
         @transformations ||= []
       end
 
-      # Create and return a new instance of Transproc::Transformer
-      # evaluating the block argument as the class body
-      #
       # @api private
-      def create(container, &block)
-        klass = self[container]
-        klass.instance_eval(&block)
-        klass
+      def ensure_container_presence!
+        return if defined?(@container)
+        raise ArgumentError, 'Transformer function registry is empty. '\
+                             'Provide your registry via Transproc::Transformer[YourRegistry]'
       end
     end
   end