transproc 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5ce7c814504a4dbdb337c06e34e0d8ba76240c2
-  data.tar.gz: 7634b2a430e84411fdf9b3454f8a9e530167efef
+  metadata.gz: 18747dd5f157b683c7f3fc9200c7a7eb084cb270
+  data.tar.gz: 6961af7f27c18df6f9da0e3b0cbf839a003c839f
 SHA512:
-  metadata.gz: 03cdc29204c0aeec12217dfc88a838d052fa3dbed8be7b66c1c8326ccd09bb9a0a2445dd4c535916da0e0fa2546340882867adcc897586e1e0f2b42244cf1c74
-  data.tar.gz: a0c2124b3455b1d240a27420214a0ba5b31c8114a2002032fba26e02938fdb1ed99183a2b4a01bfdc250e16fd58a06b92612a78f5b7c8e017e95ab20bf6efabe
+  metadata.gz: 51f5533988a1658e74988a7176936aac2d97925624720ac74dc5ca3ffc51651f61732947e645a3b65ed430992d442ae5aff4d8d35a81acc2bcaae45a7bdb9d77
+  data.tar.gz: 0b665c3972a08d45fed440025c3c986dfb00726615c16ed4e52c29ac9a86ca7e6e91d9cd8275f32829b638b21edea9a4ba8813b8e673f0839e9576d54d4cefa0

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v0.2.4 2015-06-20
+
+### Added
+
+* `Transproc::Registry` extension for registering reusable functions within modules (nepalez)
+* `:recursion` recurse over an enumerable (AMHOL)
+
+###  Changed
+
+* `:group`, `:nest`, and `:wrap` support adding new data to existing groups/wraps (nepalez)
+* `Transproc::MalformedInputError` includes original backtrace now (solnic)
+
+[Compare v0.2.3...v0.2.4](https://github.com/solnic/transproc/compare/v0.2.3...v0.2.4)
+
 ## v0.2.3 2015-06-02
 
 ### Added

data/Gemfile

@@ -5,9 +5,12 @@ gemspec
 group :test do
   gem 'equalizer'
   gem 'anima'
-  gem 'mutant'
-  gem 'mutant-rspec'
   gem 'codeclimate-test-reporter', require: nil
+
+  platform :mri do
+    gem 'mutant', github: 'mbj/mutant', branch: 'master'
+    gem 'mutant-rspec'
+  end
 end
 
 group :tools do

data/lib/transproc.rb

@@ -3,6 +3,7 @@ require 'transproc/function'
 require 'transproc/functions'
 require 'transproc/composer'
 require 'transproc/error'
+require 'transproc/registry'
 
 module Transproc
   module_function
@@ -21,7 +22,7 @@ module Transproc
   def register(*args, &block)
     name, fn = *args
     if functions.include?(name)
-      raise FunctionAlreadyRegisteredError, "function #{name} is already defined"
+      raise FunctionAlreadyRegisteredError, "Function #{name} is already defined"
     end
     functions[name] = fn || block
   end
@@ -33,7 +34,7 @@ module Transproc
   # @api private
   def [](name)
     functions.fetch(name) {
-      raise FunctionNotFoundError, "no registered function for #{name}"
+      raise FunctionNotFoundError, "No registered function for #{name}"
     }
   end
 

data/lib/transproc/array.rb

@@ -1,3 +1,5 @@
+require 'transproc/coercions'
+
 module Transproc
   # Transformation functions for Array objects
   #
@@ -87,13 +89,15 @@ module Transproc
     def group(array, key, keys)
       grouped = Hash.new { |h, k| h[k] = [] }
       array.each do |hash|
-        hash = hash.dup
-        child = {}
-        keys.each { |k| child[k] = hash.delete(k) }
-        grouped[hash] << child
+        hash = Hash[hash]
+
+        old_group = Transproc::Coercions.to_tuples(hash.delete(key))
+        new_group = keys.inject({}) { |a, e| a.merge(e => hash.delete(e)) }
+
+        grouped[hash] << old_group.map { |item| item.merge(new_group) }
       end
       grouped.map do |root, children|
-        root.merge(key => children)
+        root.merge(key => children.flatten)
       end
     end
 

data/lib/transproc/coercions.rb

@@ -153,5 +153,25 @@ module Transproc
     def 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
+    #   Transproc(:to_tuples)[:foo]                  # => [{}]
+    #   Transproc(:to_tuples)[[]]                    # => [{}]
+    #   Transproc(:to_tuples)[[{ foo: :FOO, :bar }]] # => [{ foo: :FOO }]
+    #
+    # @param [Object] value
+    #
+    # @return [Array<Hash>]
+    #
+    def to_tuples(value)
+      array = value.is_a?(Array) ? Array[*value] : [{}]
+      array.select! { |item| item.is_a?(Hash) }
+      array.any? ? array : [{}]
+    end
   end
 end

data/lib/transproc/error.rb

@@ -4,13 +4,14 @@ module Transproc
   FunctionAlreadyRegisteredError = Class.new(Error)
 
   class MalformedInputError < Error
+    attr_reader :function, :value, :original_error
+
     def initialize(function, value, error)
       @function = function
       @value = value
       @original_error = error
-      super("failed to call function #{function} on #{value}, #{error}")
+      super "Failed to call_function #{function} with #{value.inspect} - #{error}"
+      set_backtrace(error.backtrace)
     end
-
-    attr_reader :function, :value, :original_error
   end
 end

data/lib/transproc/function.rb

@@ -23,9 +23,9 @@ module Transproc
     attr_reader :args
 
     # @api private
-    def initialize(fn, options = {})
+    def initialize(fn, options)
       @fn = fn
-      @args = options.fetch(:args) { [] }
+      @args = options[:args]
     end
 
     # Call the wrapped proc
@@ -37,8 +37,8 @@ module Transproc
     # @api public
     def call(*value)
       fn[*value, *args]
-    rescue => ex
-      raise MalformedInputError.new(@fn, value, ex)
+    rescue => e
+      raise MalformedInputError.new(@fn, value, e)
     end
     alias_method :[], :call
 
@@ -63,7 +63,7 @@ module Transproc
     #
     # @api public
     def to_ast
-      identifier = fn.is_a?(::Proc) ? fn : fn.name
+      identifier = fn.instance_of?(Proc) ? fn : fn.name
       [identifier, args]
     end
   end

data/lib/transproc/hash.rb

@@ -174,7 +174,7 @@ module Transproc
     #
     # @example
     #   Transproc(:accept_keys, [:name])[name: 'Jane', email: 'jane@doe.org']
-    #   # => {:email => "jane@doe.org"}
+    #   # => {:name=>"Jane"}
     #
     # @param [Hash] hash The input hash
     # @param [Array] keys The keys to be accepted
@@ -244,7 +244,9 @@ module Transproc
 
       if nest_keys.size > 0
         child = Hash[nest_keys.zip(nest_keys.map { |key| hash.delete(key) })]
-        hash.update(root => child)
+        old_nest = hash[root]
+        new_nest = old_nest.is_a?(Hash) ? old_nest.merge(child) : child
+        hash.update(root => new_nest)
       else
         hash.update(root => {})
       end
@@ -302,7 +304,7 @@ module Transproc
     #
     # @api public
     def fold(hash, key, tuple_key)
-      fold!(hash.dup, key, tuple_key)
+      fold!(Hash[hash], key, tuple_key)
     end
 
     # Same as `:fold` but mutates the hash
@@ -311,7 +313,7 @@ module Transproc
     #
     # @api public
     def fold!(hash, key, tuple_key)
-      hash.merge!(key => ArrayTransformations.extract_key(hash[key], tuple_key))
+      hash.update(key => ArrayTransformations.extract_key(hash[key], tuple_key))
     end
 
     # Splits hash to array by all values from a specified key
@@ -328,7 +330,7 @@ module Transproc
     #       { title: 'be cool'                 }
     #     ]
     #   }
-    #   Transproc(:split, :tasks, [:priority])
+    #   Transproc(:split, :tasks, [:priority])[input]
     #   => [
     #       { name: 'Joe', priority: 1,   tasks: [{ title: 'sleep well' }]              },
     #       { name: 'Joe', priority: 2,   tasks: [{ title: 'be nice' }, { title: nil }] },

data/lib/transproc/recursion.rb

@@ -17,10 +17,50 @@ module Transproc
   module Recursion
     extend Functions
 
+    IF_ENUMERABLE = -> fn { Transproc(:is, Enumerable, fn) }
+
     IF_ARRAY = -> fn { Transproc(:is, Array, fn) }
 
     IF_HASH = -> fn { Transproc(:is, Hash, fn) }
 
+    # Recursively apply the provided transformation function to an enumerable
+    #
+    # @example
+    #   Transproc(:recursion, Transproc(:is, ::Hash, Transproc(: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 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
@@ -36,7 +76,7 @@ module Transproc
     # @api public
     def array_recursion(value, fn)
       result = fn[value]
-      guarded = IF_ARRAY[-> v { Transproc(:array_recursion, fn)[v] }]
+      guarded = IF_ARRAY[-> v { array_recursion(v, fn) }]
 
       result.map! do |item|
         guarded[item]
@@ -58,7 +98,7 @@ module Transproc
     # @api public
     def hash_recursion(value, fn)
       result = fn[value]
-      guarded = IF_HASH[-> v { Transproc(:hash_recursion, fn)[v] }]
+      guarded = IF_HASH[-> v { hash_recursion(v, fn) }]
 
       result.keys.each do |key|
         result[key] = guarded[result.delete(key)]

data/lib/transproc/registry.rb

@@ -0,0 +1,126 @@
+module Transproc
+  # Container to define transproc functions in, and access them via `[]` method
+  # from the outside of the module
+  #
+  # @example
+  #   module FooMethods
+  #     extend Transproc::Registry
+  #
+  #     def foo(name, prefix)
+  #       [prefix, '_', name].join
+  #     end
+  #   end
+  #
+  #   fn = FooMethods[:foo, 'baz']
+  #   fn['qux'] # => 'qux_baz'
+  #
+  #   module BarMethods
+  #     # extend Transproc::Registry
+  #     include FooMethods
+  #
+  #     def 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 transproc function either from a Proc, or from the module method
+    #
+    # @param [Proc, Symbol] fn
+    #   Either a proc, or a name of the module's function to be wrapped to transproc
+    # @param [Object, Array] args
+    #   Args to be carried by the transproc
+    #
+    # @return [Transproc::Function]
+    #
+    # @alias :t
+    #
+    # @api public
+    def [](fn, *args)
+      fun = fn.is_a?(Proc) ? fn : method(fn).to_proc
+      Transproc::Function.new(fun, args: args)
+    end
+    alias_method :t, :[]
+
+    # Forwards the named method (transproc) to another module
+    #
+    # Allows using transprocs from other modules without including those
+    # modules as a whole
+    #
+    # @example
+    #   module Foo
+    #     extend Transproc::Registry
+    #
+    #     def foo(value)
+    #       value.upcase
+    #     end
+    #
+    #     def bar(value)
+    #       value.downcase
+    #     end
+    #  end
+    #
+    #  module Bar
+    #     extend Transproc::Registry
+    #
+    #     uses :foo, from: Foo, as: :baz
+    #     uses :bar, from: Foo
+    #  end
+    #
+    #  Bar[:baz]['Qux'] # => 'QUX'
+    #  Bar[:bar]['Qux'] # => 'qux'
+    #
+    # @param [String, Symbol] name
+    # @option [Class] :from The module to take the method from
+    # @option [String, Symbol] :as
+    #   The name of imported transproc inside the current module
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def uses(name, options = {})
+      source   = options.fetch(:from)
+      new_name = options.fetch(:as, name)
+      define_method(new_name) { |*args| source.__send__(name, *args) }
+    end
+
+    # @api private
+    def self.extended(target)
+      target.extend(ClassMethods)
+    end
+
+    # @api private
+    module ClassMethods
+      # Makes `[]` and all functions defined in the included modules
+      # accessible in their receiver
+      #
+      # @api private
+      def included(other)
+        other.extend(Transproc::Registry, self)
+      end
+
+      # Makes newly module-defined functions accessible via `[]` method
+      # by adding it to the module's eigenclass
+      #
+      # @api private
+      def method_added(name)
+        module_function(name)
+      end
+
+      # Makes undefined methods inaccessible via `[]` method by
+      # undefining it from the module's eigenclass
+      #
+      # @api private
+      def method_undefined(name)
+        singleton_class.__send__(:undef_method, name)
+      end
+    end
+  end
+end

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = '0.2.3'.freeze
+  VERSION = '0.2.4'.freeze
 end

data/spec/spec_helper.rb

@@ -12,6 +12,9 @@ begin
 rescue LoadError
 end
 
+root = Pathname(__FILE__).dirname
+Dir[root.join('support/*.rb').to_s].each { |f| require f }
+
 RSpec.configure do |config|
   config.include(Transproc::Helper)
 end

data/spec/support/mutant.rb

@@ -0,0 +1,10 @@
+module Mutant
+  class Selector
+    # Expression based test selector
+    class Expression < self
+      def call(_subject)
+        integration.all_tests
+      end
+    end # Expression
+  end # Selector
+end # Mutant

data/spec/unit/array_transformations_spec.rb

@@ -175,17 +175,69 @@ describe Transproc::ArrayTransformations do
 
       expect(wrap[input]).to eql(output)
     end
+
+    it 'adds data to the existing tuples' do
+      wrap = t(:wrap, :task, [:title])
+
+      input  = [{ name: 'Jane', task: { priority: 1 }, title: 'One' }]
+      output = [{ name: 'Jane', task: { priority: 1, title: 'One' } }]
+
+      expect(wrap[input]).to eql(output)
+    end
   end
 
   describe '.group' do
-    it 'returns a new array with grouped hashes' do
-      group = t(:group, :tasks, [:title])
+    subject(:group) { t(:group, :tasks, [:title]) }
 
-      input = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+    it 'returns a new array with grouped hashes' do
+      input  = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
       output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
 
       expect(group[input]).to eql(output)
     end
+
+    it 'updates the existing group' do
+      input  = [
+        {
+          name: 'Jane',
+          title: 'One',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        },
+        {
+          name: 'Jane',
+          title: 'Two',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        }
+      ]
+      output = [
+        {
+          name: 'Jane',
+          tasks: [
+            { title: 'One', type: 'one' },
+            { title: 'One', type: 'two' },
+            { title: 'Two', type: 'one' },
+            { title: 'Two', type: 'two' }
+          ]
+        }
+      ]
+
+      expect(group[input]).to eql(output)
+    end
+
+    it 'ingnores old values except for array of tuples' do
+      input  = [
+        { name: 'Jane', title: 'One',   tasks: [{ priority: 1 }, :wrong] },
+        { name: 'Jane', title: 'Two',   tasks: :wrong }
+      ]
+      output = [
+        {
+          name: 'Jane',
+          tasks: [{ title: 'One', priority: 1 }, { title: 'Two' }]
+        }
+      ]
+
+      expect(group[input]).to eql(output)
+    end
   end
 
   describe '.ungroup' do
@@ -211,6 +263,34 @@ describe Transproc::ArrayTransformations do
 
       expect(ungroup[input]).to eql(output)
     end
+
+    it 'ungroups array partially' do
+      input = [
+        {
+          name: 'Jane',
+          tasks: [
+            { title: 'One', type: 'one' },
+            { title: 'One', type: 'two' },
+            { title: 'Two', type: 'one' },
+            { title: 'Two', type: 'two' }
+          ]
+        }
+      ]
+      output = [
+        {
+          name: 'Jane',
+          title: 'One',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        },
+        {
+          name: 'Jane',
+          title: 'Two',
+          tasks: [{ type: 'one' }, { type: 'two' }]
+        }
+      ]
+
+      expect(ungroup[input]).to eql(output)
+    end
   end
 
   describe '.combine' do

data/spec/unit/coercions_spec.rb

@@ -79,4 +79,38 @@ describe Transproc::Coercions do
       end
     end
   end
+
+  describe '.to_tuples' do
+    subject(:to_tuples) { t(:to_tuples) }
+
+    context 'non-array' do
+      let(:input) { :foo }
+
+      it 'returns an array with one blank tuple' do
+        output = [{}]
+
+        expect(to_tuples[input]).to eql(output)
+      end
+    end
+
+    context 'empty array' do
+      let(:input) { [] }
+
+      it 'returns an array with one blank tuple' do
+        output = [{}]
+
+        expect(to_tuples[input]).to eql(output)
+      end
+    end
+
+    context 'array of tuples' do
+      let(:input) { [:foo, { bar: :BAZ }, :qux] }
+
+      it 'returns an array with tuples only' do
+        output = [{ bar: :BAZ }]
+
+        expect(to_tuples[input]).to eql(output)
+      end
+    end
+  end
 end

data/spec/unit/hash_transformations_spec.rb

@@ -172,6 +172,28 @@ describe Transproc::HashTransformations do
       expect(input).to eql(output)
     end
 
+    it 'returns new hash with keys nested under the existing key' do
+      nest = t(:nest!, :baz, ['two'])
+
+      input  = { 'foo' => 'bar', baz: { 'one' => nil }, 'two' => false }
+      output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
+
+      nest[input]
+
+      expect(input).to eql(output)
+    end
+
+    it 'rewrites the existing key if its value is not a hash' do
+      nest = t(:nest!, :baz, ['two'])
+
+      input  = { 'foo' => 'bar', baz: 'one', 'two' => false }
+      output = { 'foo' => 'bar', baz: { 'two' => false } }
+
+      nest[input]
+
+      expect(input).to eql(output)
+    end
+
     it 'returns new hash with an empty hash under a new key when nest-keys are missing' do
       nest = t(:nest!, :baz, ['foo'])
 

data/spec/unit/recursion_spec.rb

@@ -1,6 +1,58 @@
 require 'spec_helper'
 
 describe Transproc::Recursion do
+  describe '.recursion' do
+    let(:original) do
+      {
+        'foo' => 'bar',
+        'bar' => {
+          'foo' => 'bar',
+          'bar' => ['foo', 'bar', 'baz'],
+          'baz' => 'foo'
+        },
+        'baz' => 'bar'
+      }
+    end
+
+    let(:input) { original.dup }
+
+    let(:output) do
+      {
+        'foo' => 'bar',
+        'bar' => {
+          'foo' => 'bar',
+          'bar' => ['foo', 'bar'],
+        }
+      }
+    end
+
+    context 'when function is non-destructive' do
+      let(:map) do
+        t(:recursion, -> enum {
+          enum.reject { |v| v == 'baz' }
+        })
+      end
+
+      it 'applies funtions to all items recursively' do
+        expect(map[input]).to eql(output)
+        expect(input).to eql(original)
+      end
+    end
+
+    context 'when function is destructive' do
+      let(:map) do
+        t(:recursion, -> enum {
+          enum.reject! { |v| v == 'baz' }
+        })
+      end
+
+      it 'applies funtions to all items recursively and destructively' do
+        expect(map[input]).to eql(output)
+        expect(input).to eql(output)
+      end
+    end
+  end
+
   describe '.array_recursion' do
     let(:original) do
       [

data/spec/unit/registry_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Transproc::Registry do
+  before do
+    module FooModule
+      extend Transproc::Registry
+
+      def foo(value, prefix)
+        [prefix, '_', value].join
+      end
+    end
+
+    module BarModule
+      include FooModule
+
+      def bar(*args)
+        foo(*args).upcase
+      end
+    end
+
+    module BazModule
+      extend Transproc::Registry
+    end
+  end
+
+  describe '.[]' do
+    it 'builds function from the method' do
+      fn = ::FooModule[:foo, 'baz']
+
+      expect(fn['qux']).to eql 'baz_qux'
+    end
+
+    it 'builds function from the proc' do
+      fun = -> value, prefix { [prefix, '_', value].join }
+      fn  = ::FooModule[fun, 'baz']
+
+      expect(fn['qux']).to eql 'baz_qux'
+    end
+
+    it 'builds function using methods from included modules' do
+      fn = ::BarModule[:bar, 'baz']
+
+      expect(fn['qux']).to eql 'BAZ_QUX'
+    end
+
+    it 'can access methods from included modules directly' do
+      fn = ::BarModule[:foo, 'baz']
+
+      expect(fn['qux']).to eql 'baz_qux'
+    end
+
+    it 'cannot access undefined methods' do
+      module ::BarModule
+        undef_method :foo
+      end
+
+      expect { ::BarModule[:foo, 'baz'] }.to raise_error(NameError)
+    end
+  end
+
+  describe '.uses' do
+    it 'forwards methods to another module directly' do
+      expect { ::BazModule[:baz, 'baz'] }.to raise_error(NameError)
+
+      module BazModule
+        uses :foo, as: :ffoo, from: FooModule
+        uses :bar, from: BarModule
+      end
+
+      ffoo = ::BazModule[:ffoo, 'baz']
+      bar  = ::BazModule[:bar, 'baz']
+
+      expect(ffoo['qux']).to eql 'baz_qux'
+      expect(bar['qux']).to eql 'BAZ_QUX'
+    end
+  end
+
+  describe '#t' do
+    it 'is an alias for .[]' do
+      module FooModule
+        def qux(value, *args)
+          t(:foo, *args)[value]
+        end
+      end
+
+      fn = ::FooModule[:foo, 'baz']
+
+      expect(fn['qux']).to eql 'baz_qux'
+    end
+  end
+
+  after { Object.send :remove_const, :BazModule }
+  after { Object.send :remove_const, :BarModule }
+  after { Object.send :remove_const, :FooModule }
+end

data/spec/unit/transproc_spec.rb

@@ -52,13 +52,17 @@ describe Transproc do
 
   describe 'handling malformed input' do
     it 'raises a Transproc::MalformedInputError' do
-      Transproc.register(:im_dangerous, ->() {
-        raise ArgumentError, 'sorry, you got some bad apples in your input'
-      })
-
       expect {
-        Transproc(:im_dangerous)[hello: 'world']
+        Transproc(:to_integer)[{}]
       }.to raise_error(Transproc::MalformedInputError)
+
+      begin
+        Transproc(:to_integer)[{}]
+      rescue Transproc::MalformedInputError => e
+        expect(e.message).to include('to_integer')
+        expect(e.message).to include("undefined method `to_i'")
+        expect(e.backtrace).to eql(e.original_error.backtrace)
+      end
     end
   end
 end

data/transproc.gemspec

@@ -20,5 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rspec', '~> 3.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transproc
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-02 00:00:00.000000000 Z
+date: 2015-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.3'
 description: Transform Ruby objects in functional style
 email:
 - piotr.solnica@gmail.com
@@ -83,10 +83,12 @@ files:
 - lib/transproc/functions.rb
 - lib/transproc/hash.rb
 - lib/transproc/recursion.rb
+- lib/transproc/registry.rb
 - lib/transproc/version.rb
 - rakelib/mutant.rake
 - rakelib/rubocop.rake
 - spec/spec_helper.rb
+- spec/support/mutant.rb
 - spec/unit/array_transformations_spec.rb
 - spec/unit/class_transformations_spec.rb
 - spec/unit/coercions_spec.rb
@@ -95,6 +97,7 @@ files:
 - spec/unit/function_spec.rb
 - spec/unit/hash_transformations_spec.rb
 - spec/unit/recursion_spec.rb
+- spec/unit/registry_spec.rb
 - spec/unit/transproc_spec.rb
 - transproc.gemspec
 homepage: http://solnic.github.io/transproc/
@@ -123,6 +126,7 @@ specification_version: 4
 summary: Transform Ruby objects in functional style
 test_files:
 - spec/spec_helper.rb
+- spec/support/mutant.rb
 - spec/unit/array_transformations_spec.rb
 - spec/unit/class_transformations_spec.rb
 - spec/unit/coercions_spec.rb
@@ -131,4 +135,5 @@ test_files:
 - spec/unit/function_spec.rb
 - spec/unit/hash_transformations_spec.rb
 - spec/unit/recursion_spec.rb
+- spec/unit/registry_spec.rb
 - spec/unit/transproc_spec.rb