transproc 0.2.0 → 0.2.1

data/lib/transproc/conditional.rb

@@ -1,5 +1,4 @@
 module Transproc
-
   # Conditional transformation functions
   #
   # @example

data/lib/transproc/error.rb

@@ -0,0 +1,16 @@
+module Transproc
+  Error = Class.new(StandardError)
+  FunctionNotFoundError = Class.new(Error)
+  FunctionAlreadyRegisteredError = Class.new(Error)
+
+  class MalformedInputError < Error
+    def initialize(function, value, error)
+      @function = function
+      @value = value
+      @original_error = error
+      super("failed to call function #{function} on #{value}, #{error}")
+    end
+
+    attr_reader :function, :value, :original_error
+  end
+end

data/lib/transproc/function.rb

@@ -1,3 +1,5 @@
+require 'transproc/composite'
+
 module Transproc
   # Transformation proc wrapper allowing composition of multiple procs into
   # a data-transformation pipeline.
@@ -33,8 +35,10 @@ module Transproc
     # @alias []
     #
     # @api public
-    def call(value)
-      fn[value, *args]
+    def call(*value)
+      fn[*value, *args]
+    rescue => ex
+      raise MalformedInputError.new(@fn, value, ex)
     end
     alias_method :[], :call
 
@@ -48,7 +52,7 @@ module Transproc
     #
     # @api public
     def compose(other)
-      Composite.new(self, right: other)
+      Composite.new(self, other)
     end
     alias_method :+, :compose
     alias_method :>>, :compose
@@ -59,54 +63,8 @@ module Transproc
     #
     # @api public
     def to_ast
-      identifier = Proc === fn ? fn : fn.name
+      identifier = fn.is_a?(::Proc) ? fn : fn.name
       [identifier, args]
     end
-
-    # Composition of two functions
-    #
-    # @api private
-    class Composite < Function
-      alias_method :left, :fn
-
-      # @return [Proc]
-      #
-      # @api private
-      attr_reader :right
-
-      # @api private
-      def initialize(fn, options = {})
-        super
-        @right = options.fetch(: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[left[value]]
-      end
-      alias_method :[], :call
-
-      # @see Function#compose
-      #
-      # @api public
-      def compose(other)
-        Composite.new(self, right: 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/transproc/hash.rb

@@ -145,10 +145,60 @@ module Transproc
       hash
     end
 
+    # Same as `:reject_keys` but mutates the hash
+    #
+    # @see HashTransformations.reject_keys
+    #
+    # @api public
+    def reject_keys!(hash, keys)
+      hash.reject { |k,_| keys.include?(k) }
+    end
+
+    # Rejects specified keys from a hash
+    #
+    # @example
+    #   Transproc(:reject_keys, [:name])[name: 'Jane', email: 'jane@doe.org']
+    #   # => {:email => "jane@doe.org"}
+    #
+    # @param [Hash] hash The input hash
+    # @param [Array] keys The keys to be rejected
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def reject_keys(hash, keys)
+      reject_keys!(Hash[hash], keys)
+    end
+
+    # Same as `:accept_keys` but mutates the hash
+    #
+    # @see HashTransformations.reject_keys
+    #
+    # @api public
+    def accept_keys!(hash, keys)
+      reject_keys!(hash, hash.keys - keys)
+    end
+
+    # Accepts specified keys from a hash
+    #
+    # @example
+    #   Transproc(:accept_keys, [:name])[name: 'Jane', email: 'jane@doe.org']
+    #   # => {:email => "jane@doe.org"}
+    #
+    # @param [Hash] hash The input hash
+    # @param [Array] keys The keys to be accepted
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def accept_keys(hash, keys)
+      accept_keys!(Hash[hash], keys)
+    end
+
     # Map a key in a hash with the provided transformation function
     #
     # @example
-    #   Transproc(:map_value, -> s { s.upcase })['name' => 'jane']
+    #   Transproc(:map_value, 'name', -> s { s.upcase })['name' => 'jane']
     #   # => {"name" => "JANE"}
     #
     # @param [Hash]
@@ -211,7 +261,7 @@ module Transproc
     # @return [Hash]
     #
     # @api public
-    def unwrap(hash, root, keys)
+    def unwrap(hash, root, keys = nil)
       copy = Hash[hash].merge(root => Hash[hash[root]])
       unwrap!(copy, root, keys)
     end

data/lib/transproc/object.rb

@@ -0,0 +1,19 @@
+module Transproc
+  # Transformation functions for Objects
+  #
+  # @example
+  #   require 'transproc/object'
+  #
+  #   include Transproc::Helper
+  #
+  #   fn = t(:set_ivars, { name: 'Jane', age: 25 })
+  #
+  #   fn[Object.new]
+  #   # => #<Object:0x007f73afe7d6f8 @name="Jane", @age=25>
+  #
+  # @api public
+  module ObjectTransformations
+    extend Functions
+
+  end
+end

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.2.1'.freeze
 end

data/rakelib/mutant.rake

@@ -0,0 +1,16 @@
+desc "Run mutant against a specific subject"
+task :mutant do
+  subject = ARGV.last
+  if subject == 'mutant'
+    abort "usage: rake mutant SUBJECT\nexample: rake mutant Transproc::Recursion"
+  else
+    opts = {
+      'include' => 'lib',
+      'require' => 'transproc/all',
+      'use' => 'rspec',
+      'ignore-subject' => "#{subject}#respond_to_missing?"
+    }.to_a.map { |k, v| "--#{k} #{v}" }.join(' ')
+
+    exec("bundle exec mutant #{opts} #{subject}")
+  end
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+begin
+  require 'rubocop/rake_task'
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names'
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec 'bundle exec rubocop --auto-gen-config'
+    end
+  end
+
+rescue LoadError
+end

data/spec/spec_helper.rb

@@ -1,8 +1,10 @@
-if RUBY_ENGINE == "rbx"
-  require "codeclimate-test-reporter"
+if RUBY_ENGINE == 'rbx'
+  require 'codeclimate-test-reporter'
   CodeClimate::TestReporter.start
 end
 
+require 'equalizer'
+require 'anima'
 require 'transproc/all'
 
 begin

data/spec/unit/array_transformations_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Transproc::ArrayTransformations do
+  describe '.extract_key' do
+    it 'extracts values by key from all hashes' do
+      extract_key = t(:extract_key, 'name')
+
+      original = [
+        { 'name' => 'Alice', 'role' => 'sender' },
+        { 'name' => 'Bob', 'role' => 'receiver' },
+        { 'role' => 'listener' }
+      ]
+
+      input = original
+
+      output = ['Alice', 'Bob', nil]
+
+      expect(extract_key[input]).to eql(output)
+      expect(input).to eql(original)
+    end
+  end
+
+  describe '.extract_key!' do
+    it 'extracts values by key from all hashes' do
+      extract_key = t(:extract_key!, 'name')
+
+      input = [
+        { 'name' => 'Alice', 'role' => 'sender' },
+        { 'name' => 'Bob', 'role' => 'receiver' },
+        { 'role' => 'listener' }
+      ]
+
+      output = ['Alice', 'Bob', nil]
+
+      extract_key[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe '.map_array' do
+    it 'applies funtions to all values' do
+      map = t(:map_array, t(:symbolize_keys))
+
+      original = [
+        { 'name' => 'Jane', 'title' => 'One' },
+        { 'name' => 'Jane', 'title' => 'Two' }
+      ]
+
+      input = original
+
+      output = [
+        { name: 'Jane', title: 'One' },
+        { name: 'Jane', title: 'Two' }
+      ]
+
+      expect(map[input]).to eql(output)
+      expect(input).to eql(original)
+    end
+  end
+
+  describe '.map_array!' do
+    it 'updates array with the result of the function applied to each value' do
+      map = t(:map_array!, t(:symbolize_keys))
+
+      input = [
+        { 'name' => 'Jane', 'title' => 'One' },
+        { 'name' => 'Jane', 'title' => 'Two' }
+      ]
+
+      output = [
+        { name: 'Jane', title: 'One' },
+        { name: 'Jane', title: 'Two' }
+      ]
+
+      map[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe '.wrap' do
+    it 'returns a new array with wrapped hashes' do
+      wrap = t(:wrap, :task, [:title])
+
+      input = [{ name: 'Jane', title: 'One' }]
+      output = [{ name: 'Jane', task: { title: 'One' } }]
+
+      expect(wrap[input]).to eql(output)
+    end
+
+    it 'returns a array new with deeply wrapped hashes' do
+      wrap =
+        t(
+          :map_array,
+          t(:nest, :user, [:name, :title]) +
+          t(:map_value, :user, t(:nest, :task, [:title]))
+        )
+
+      input = [{ name: 'Jane', title: 'One' }]
+      output = [{ user: { name: 'Jane', task: { 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])
+
+      input = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+      output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
+
+      expect(group[input]).to eql(output)
+    end
+  end
+
+  describe '.combine' do
+    let(:input) do
+      [
+        # parent users
+        [
+          { name: 'Jane', email: 'jane@doe.org' },
+          { name: 'Joe', email: 'joe@doe.org' }
+        ],
+        [
+          [
+            # user tasks
+            [
+              { user: 'Jane', title: 'One' },
+              { user: 'Jane', title: 'Two' },
+              { user: 'Joe', title: 'Three' }
+            ],
+            [
+              # task tags
+              [
+                { task: 'One', tag: 'red' },
+                { task: 'Three', tag: 'blue' }
+              ]
+            ]
+          ]
+        ]
+      ]
+    end
+
+    let(:output) do
+      [
+        { name: 'Jane', email: 'jane@doe.org', tasks: [
+          { user: 'Jane', title: 'One', tags: [{ task: 'One', tag: 'red' }] },
+          { user: 'Jane', title: 'Two', tags: [] } ]
+        },
+        { name: 'Joe', email: 'joe@doe.org', tasks: [
+          { user: 'Joe', title: 'Three', tags: [{ task: 'Three', tag: 'blue' }] } ]
+        }
+      ]
+    end
+
+    it 'merges hashes from arrays using provided join keys' do
+      combine = t(:combine, [
+        [:tasks, { name: :user }, [[:tags, title: :task]]]
+      ])
+
+      expect(combine[input]).to eql(output)
+    end
+  end
+end

data/spec/unit/class_transformations_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Transproc::ClassTransformations do
+  describe '.constructor_inject' do
+    let(:klass) do
+      Struct.new(:name, :age) { include Equalizer.new(:name, :age) }
+    end
+
+    it 'returns a new object initialized with the given arguments' do
+      constructor_inject = t(:constructor_inject, klass)
+
+      input = ['Jane', 25]
+      output = klass.new(*input)
+      result = constructor_inject[*input]
+
+      expect(result).to eql(output)
+      expect(result).to be_instance_of(klass)
+    end
+  end
+
+  describe '.set_ivars' do
+    let(:klass) do
+      Class.new do
+        include Anima.new(:name, :age)
+
+        attr_reader :test
+
+        def initialize(*args)
+          super
+          @test = true
+        end
+      end
+    end
+
+    it 'allocates a new object and sets instance variables from hash key/value pairs' do
+      set_ivars = t(:set_ivars, klass)
+
+      input = { name: 'Jane', age: 25 }
+      output = klass.new(input)
+      result = set_ivars[input]
+
+      expect(result).to eql(output)
+      expect(result.test).to be(nil)
+      expect(result).to be_instance_of(klass)
+    end
+  end
+end