enzymator 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2ec2a4060b6cda9e9556c05b4feb7f8188b91ed
-  data.tar.gz: 5c01a79eed612fc1c63a7a496695ef5898e7f38f
+  metadata.gz: db6b848beb8684576018917cc3294e62ee74c9b9
+  data.tar.gz: 13464a8ce27e97366cdd446ade0f40ef1d9c96fe
 SHA512:
-  metadata.gz: 0d7e5533db3223a545e7c175f3ffe65fa33e3d3e18c7469b1d2dd129a604fd386db91666120d8ea19d14149b7636dcfbe76c57478513bcad707a0d8ad8dc4592
-  data.tar.gz: f7200cc635e0c058d54fa50d8d28593b366f7ea5e61439d4b9c8d81e264b04ffe3a2574c12f79b369af35725707c13643806e85ac9c2c82b47b42ca4a2e25967
+  metadata.gz: 06c96d05b1719d9b82edfd21dcfef75f96a77123f7d2b20fb934f7659a012f1a60ed975d0f891042a2fec58d322ce831b4fa40b2a00cc5cf21aa42612237c5bf
+  data.tar.gz: 87eb91c6b2c7ec3afb559e8fcd450bb93e3177c78259a120ebcc83f0498a5588fec36048d547779df0953e2f97b3a96bccf68406622afda5ce2c5b693280dfc4

data/Gemfile

@@ -2,9 +2,3 @@ source 'http://rubygems.org'
 
 # Specify your gem's dependencies in enzymator.gemspec
 gemspec
-
-group :development, :test do
-  gem "rake", "~> 11.2"
-  gem "minitest", "~> 5.9"
-  gem 'pry-byebug'
-end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 eugeniobruno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,6 +1,6 @@
 # Enzymator
 
-Enzimator is an extremely simple and powerful aggregation framework. Every ruby app can use it to unleash the infinite power of the MapReduce concept. If it could tame BigData, imagine what it can do with fewer data!
+Enzymator is an extremely simple and powerful aggregation framework. Every ruby app can use it to unleash the infinite power of the MapReduce concept. If it could tame BigData, imagine what it can do with fewer data!
 
 You should take two minutes to check out the test examples.
 
@@ -8,7 +8,7 @@ You should take two minutes to check out the test examples.
 
 Add this line to your application's Gemfile:
 
-    gem 'enzimator'
+    gem 'enzymator'
 
 And then execute:
 
@@ -16,11 +16,11 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install enzimator
+    $ gem install enzymator
 
 ## Usage
 
-You set up a new Aggregation instance, tell it to run with your Enumerator, and get the result. The tests are self-explanatory.
+You set up a new transformation instance, tell it to run with your Object, and get the result. The tests are self-explanatory.
 
 ## Contributing
 

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
-  t.libs << 'test'
+  t.pattern = "test/**/test_*.rb"
 end
 
 desc "Run tests"

data/enzymator.gemspec

@@ -6,9 +6,9 @@ require 'enzymator/version'
 Gem::Specification.new do |s|
   s.name        = 'enzymator'
   s.version     = Enzymator::Version
-  s.date        = '2016-07-17'
+  s.date        = '2016-07-24'
   s.summary     = "An extremely simple and powerful aggregation framework"
-  s.description = "A gem to perform any kind of calculation on any kind of data. The essence of MapReduce distilled in a few lines of code for the ruby community to enjoy."
+  s.description = "A gem to perform any kind of transformation on any kind of data. The essence of MapReduce distilled in a few lines of code for the ruby community to enjoy."
   s.authors     = ["Eugenio Bruno"]
   s.email       = 'eugeniobruno@gmail.com'
   s.homepage    = 'http://rubygems.org/gems/enzymator'
@@ -19,4 +19,10 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
 
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_development_dependency 'rake', ['~> 11.2']
+  s.add_development_dependency 'minitest', ['~> 5.9']
+  s.add_development_dependency 'pry-byebug', ['~> 3.4']
+
 end

data/lib/enzymator.rb

@@ -1,2 +1,28 @@
-require 'enzymator/core_ext/enumerator'
-require 'enzymator/aggregation'
+require 'enzymator/core_ext/categorizer'
+require 'enzymator/core_ext/monoids'
+
+require 'enzymator/types/list/functor/enumerable'
+require 'enzymator/types/list/foldable/enumerable'
+require 'enzymator/types/list/monad/array'
+
+require 'enzymator/transformations/config'
+require 'enzymator/transformations/base'
+require 'enzymator/transformations/object/application'
+require 'enzymator/transformations/object/pipelining'
+require 'enzymator/transformations/functor/mapping'
+require 'enzymator/transformations/foldable/reduction'
+require 'enzymator/transformations/monad/join'
+
+require 'enzymator/transformers/base'
+require 'enzymator/transformers/object/simple_applicator'
+require 'enzymator/transformers/object/simple_pipeliner'
+require 'enzymator/transformers/functor/simple_mapper'
+require 'enzymator/transformers/foldable/simple_reducer'
+require 'enzymator/transformers/monad/simple_joiner'
+
+require 'enzymator/aggregations/base'
+require 'enzymator/aggregations/count'
+require 'enzymator/aggregations/sum'
+require 'enzymator/aggregations/average'
+require 'enzymator/aggregations/merge_hashes'
+require 'enzymator/aggregations/mapreduce'

data/lib/enzymator/aggregations/average.rb

@@ -0,0 +1,30 @@
+module Enzymator
+  module Aggregations
+    class Average < Base
+
+      def initialize(config = {})
+        super
+
+        @transformation = begin
+          stages = []
+
+          stages << Enzymator::Transformations::Foldable::Reduction.new({
+            append: ->(acum, n) { acum[:sum] += n; acum[:count] += 1; acum },
+            empty: Hash.new(0)
+          })
+
+          stages << Enzymator::Transformations::Object::Application.new({
+            function: ->(sum_and_count) { sum_and_count[:sum] / sum_and_count[:count] }
+          })
+
+          Enzymator::Transformations::Object::Pipelining.new({
+            stages: stages
+          })
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/enzymator/aggregations/base.rb

@@ -0,0 +1,15 @@
+module Enzymator
+  module Aggregations
+    class Base
+
+      def initialize(config = {})
+        @config = Transformations::Config.new(config)
+      end
+
+      def run_on(object)
+        @transformation.run_on(object)
+      end
+
+    end
+  end
+end

data/lib/enzymator/aggregations/count.rb

@@ -0,0 +1,18 @@
+module Enzymator
+  module Aggregations
+    class Count < Base
+
+      def initialize(config = {})
+        super
+
+        @transformation = begin
+          Enzymator::Transformations::Object::Application.new({
+          function: ->(objects) { objects.size }
+        })
+        end
+
+      end
+
+    end
+  end
+end

data/lib/enzymator/aggregations/mapreduce.rb

@@ -0,0 +1,31 @@
+module Enzymator
+  module Aggregations
+    class MapReduce < Base
+
+      def initialize(config = {})
+        super
+
+        @transformation = begin
+          stages = []
+
+          if @config.map || @config.mapping
+            stages << Enzymator::Transformations::Functor::Mapping.new({
+              map: @config.map || @config.mapping
+            })
+          end
+
+          stages << Enzymator::Transformations::Foldable::Reduction.new({
+            append:  @config.append || @config.reduction,
+            empty:   @config.empty
+          })
+
+          Enzymator::Transformations::Object::Pipelining.new({
+            stages: stages
+          })
+        end
+
+      end
+
+    end
+  end
+end

data/lib/enzymator/aggregations/merge_hashes.rb

@@ -0,0 +1,14 @@
+module Enzymator
+  module Aggregations
+    class MergeHashes < Base
+
+      def initialize(config = {})
+        super
+
+        @transformation = Enzymator::Transformations::Foldable::Reduction.new
+        # Merge is the default reduction operation for hashes
+      end
+
+    end
+  end
+end

data/lib/enzymator/aggregations/sum.rb

@@ -0,0 +1,14 @@
+module Enzymator
+  module Aggregations
+    class Sum < Base
+
+      def initialize(config = {})
+        super
+
+        @transformation = Enzymator::Transformations::Foldable::Reduction.new
+        # Summation is the default reduction operation for all numeric types
+      end
+
+    end
+  end
+end

data/lib/enzymator/core_ext/categorizer.rb

@@ -0,0 +1,23 @@
+module Enzymator
+  class Categorizer
+
+    @@known_classes = Hash.new(0)
+
+    def self.categorize(klass)
+      unless @@known_classes.has_key? klass
+
+        if klass.included_modules.include? Enumerable
+          klass.send :include, Enzymator::Types::List::Functor::Enumerable
+          klass.send :include, Enzymator::Types::List::Foldable::Enumerable
+        end
+
+        if klass <= Array
+          klass.send :include, Enzymator::Types::List::Monad::Array
+        end
+
+        @@known_classes[klass] += 1
+      end
+    end
+
+  end
+end

data/lib/enzymator/core_ext/monoids.rb

@@ -0,0 +1,76 @@
+class Fixnum
+  @enzy_mappend = ->(m, n) { m + n }.freeze
+  @enzy_mempty = 0.freeze
+  class << self
+    attr_reader :enzy_mappend
+    attr_reader :enzy_mempty
+  end
+end
+
+class Float
+  @enzy_mappend = ->(m, n) { m + n }.freeze
+  @enzy_mempty = 0.to_f.freeze
+  class << self
+    attr_reader :enzy_mappend
+    attr_reader :enzy_mempty
+  end
+end
+
+class Rational
+  @enzy_mappend = ->(m, n) { m + n }.freeze
+  @enzy_mempty = 0.to_r.freeze
+  class << self
+    attr_reader :enzy_mappend
+    attr_reader :enzy_mempty
+  end
+end
+
+class Complex
+  @enzy_mappend = ->(m, n) { m + n }.freeze
+  @enzy_mempty = 0.to_c.freeze
+  class << self
+    attr_reader :enzy_mappend
+    attr_reader :enzy_mempty
+  end
+end
+
+class Array
+  @enzy_mappend = ->(xs, ys) { xs + ys }.freeze
+  @enzy_mempty = [].freeze
+  class << self
+    attr_reader :enzy_mappend
+    #attr_reader :enzy_mempty
+    def enzy_mempty
+      @enzy_mempty.dup
+    end
+  end
+end
+
+class String
+  @enzy_mappend = ->(s, t) { s + t }.freeze
+  @enzy_mempty = ''.freeze
+  class << self
+    attr_reader :enzy_mappend
+    attr_reader :enzy_mempty
+  end
+end
+
+class Hash
+  @enzy_mappend = ->(ps, qs) { ps.merge qs }.freeze
+  @enzy_mempty = {}.freeze
+  class << self
+    attr_reader :enzy_mappend
+    attr_reader :enzy_mempty
+  end
+end
+
+if defined? HashWithIndifferentAccess
+  class HashHashWithIndifferentAccess
+    @enzy_mappend = ->(ps, qs) { ps.merge qs }.freeze
+    @enzy_mempty = {}.freeze
+    class << self
+      attr_reader :enzy_mappend
+      attr_reader :enzy_mempty
+    end
+  end
+end

data/lib/enzymator/transformations/base.rb

@@ -0,0 +1,39 @@
+module Enzymator
+  module Transformations
+    class Base
+
+      @@default_config = {
+        max_threads: 1 # TODO: use this value
+      }
+
+      def initialize(config = {})
+        @config = Config.new(interpreted(@@default_config.merge(config)))
+      end
+
+      def run_on_all(*objects)
+        # when threads are implemented, the original order must be preserved
+        objects.map { |object| run_on(object) }
+      end
+
+      def run_on(object)
+        Categorizer.categorize(object.class)
+        do_run_on(object)
+      end
+
+      private
+
+      def interpreted(config)
+        config
+      end
+
+      def do_run_on(object)
+        transformer.transform(object)
+      end
+
+      def transformer
+        transformer_class.new(@config)
+      end
+
+    end
+  end
+end

data/lib/enzymator/transformations/config.rb

@@ -0,0 +1,22 @@
+module Enzymator
+  module Transformations
+    class Config
+
+      def initialize(config)
+        @config = config.each_with_object({}) do |(k, v), hash|
+          hash[k.to_sym] = v
+        end
+        .freeze
+      end
+
+      def method_missing(name, *args, &block)
+        @config[name]
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @config.has_key?(name) || super
+      end
+
+    end
+  end
+end

data/lib/enzymator/transformations/foldable/reduction.rb

@@ -0,0 +1,22 @@
+module Enzymator
+  module Transformations
+    module Foldable
+      class Reduction < Base
+
+        protected
+
+        def transformer_class
+          Enzymator::Transformers::Foldable::SimpleReducer
+        end
+
+        def interpreted(config)
+          config.merge({
+            append: config[:append] || config[:reduction] || :mappend,
+            empty:  config[:empty]  || config[:initial]   || :mempty
+          })
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformations/functor/mapping.rb

@@ -0,0 +1,19 @@
+module Enzymator
+  module Transformations
+    module Functor
+      class Mapping < Base
+
+        protected
+
+        def transformer_class
+          Enzymator::Transformers::Functor::SimpleMapper
+        end
+
+        def interpreted(config)
+          config.merge({ map: config[:map] || config[:mapping] })
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformations/monad/join.rb

@@ -0,0 +1,15 @@
+module Enzymator
+  module Transformations
+    module Monad
+      class Join < Base
+
+        protected
+
+        def transformer_class
+          Enzymator::Transformers::Monad::SimpleJoiner
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformations/object/application.rb

@@ -0,0 +1,15 @@
+module Enzymator
+  module Transformations
+    module Object
+      class Application < Base
+
+        protected
+
+        def transformer_class
+          Enzymator::Transformers::Object::SimpleApplicator
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformations/object/pipelining.rb

@@ -0,0 +1,19 @@
+module Enzymator
+  module Transformations
+    module Object
+      class Pipelining < Base
+
+        protected
+
+        def transformer_class
+          Enzymator::Transformers::Object::SimplePipeliner
+        end
+
+        def interpreted(config)
+          config.merge({ stages: config[:stages] || config[:transformations] || [] })
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformers/base.rb

@@ -0,0 +1,11 @@
+module Enzymator
+  module Transformers
+    class Base
+
+      def initialize(config)
+        @config = config
+      end
+
+    end
+  end
+end

data/lib/enzymator/transformers/foldable/simple_reducer.rb

@@ -0,0 +1,13 @@
+module Enzymator
+  module Transformers
+    module Foldable
+      class SimpleReducer < Base
+
+        def transform(input)
+          input.enzy_fold(@config.empty, @config.append)
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformers/functor/simple_mapper.rb

@@ -0,0 +1,13 @@
+module Enzymator
+  module Transformers
+    module Functor
+      class SimpleMapper < Base
+
+        def transform(input)
+          input.enzy_fmap(@config.map)
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformers/monad/simple_joiner.rb

@@ -0,0 +1,13 @@
+module Enzymator
+  module Transformers
+    module Monad
+      class SimpleJoiner < Base
+
+        def transform(input)
+          input.enzy_join
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformers/object/simple_applicator.rb

@@ -0,0 +1,13 @@
+module Enzymator
+  module Transformers
+    module Object
+      class SimpleApplicator < Base
+
+        def transform(input)
+          @config.function.call(input)
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/transformers/object/simple_pipeliner.rb

@@ -0,0 +1,13 @@
+module Enzymator
+  module Transformers
+    module Object
+      class SimplePipeliner < Base
+
+        def transform(input)
+          @config.stages.reduce(input) { |acum, stage| stage.run_on(acum) }
+        end
+
+      end
+    end
+  end
+end

data/lib/enzymator/types/list/foldable/enumerable.rb

@@ -0,0 +1,33 @@
+module Enzymator
+  module Types
+    module List
+      module Foldable
+        module Enumerable
+
+          def enzy_fold(empty, append)
+            append = enzy_mappend if append == :mappend
+            empty  = enzy_mempty  if empty  == :mempty
+
+            reduce(empty, &append)
+          end
+
+          private
+
+          def enzy_mappend
+            enzy_inner_type.enzy_mappend
+          end
+
+          def enzy_mempty
+            enzy_inner_type.enzy_mempty
+          end
+
+          def enzy_inner_type
+            first_elem = first
+            first_elem.nil? ? :missing_inner_type : first_elem.class
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/enzymator/types/list/functor/enumerable.rb

@@ -0,0 +1,13 @@
+module Enzymator
+  module Types
+    module List
+      module Functor
+        module Enumerable
+          def enzy_fmap(f)
+            map(&f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enzymator/types/list/monad/array.rb

@@ -0,0 +1,17 @@
+module Enzymator
+  module Types
+    module List
+      module Monad
+        module Array
+          include List::Functor::Enumerable
+          def self.enzy_unit(object)
+            [object]
+          end
+          def enzy_join
+            flatten(1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enzymator/version.rb

@@ -1,13 +1,12 @@
 module Enzymator
   class Version
-    MAJOR = 0
+    MAJOR = 1
     MINOR = 0
-    PATCH = 1
+    PATCH = 0
     PRE = nil
 
     class << self
 
-      # @return [String]
       def to_s
         [MAJOR, MINOR, PATCH, PRE].compact.join('.')
       end

data/test/aggregations/test_average.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestAverage < Minitest::Test
+
+  def test_average
+    numbers = (1..10).to_a
+    expected = (1..10).reduce(:+) / 10
+
+    actual = Enzymator::Aggregations::Average.new.run_on(numbers)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/aggregations/test_count.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestCount < Minitest::Test
+
+  def test_count
+    numbers = (1..10).to_a
+    expected = numbers.length
+
+    actual = Enzymator::Aggregations::Count.new.run_on(numbers)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/aggregations/test_merge_hashes.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestMergeHashes < Minitest::Test
+
+  def test_merge_hashes
+    hashes = [ { 'a' => 1, 'b' => 2, 'c' => 3 }, { 'd' => 4 }, { 'e' => 5 } ]
+    expected = { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }
+
+    actual = Enzymator::Aggregations::MergeHashes.new.run_on(hashes)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/aggregations/test_sum.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestSum < Minitest::Test
+
+  def test_sum
+    numbers = (1..10).to_a
+    expected = (1..10).reduce(:+)
+
+    actual = Enzymator::Aggregations::Sum.new.run_on(numbers)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/{test_aggregation.rb → test_introduction.rb}

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 require 'enzymator'
 
-class AggregationTest < Minitest::Test
+class TestIntroduction < Minitest::Test
 
   def test_sum_numbers
     numbers = (1..1000).to_a
@@ -9,10 +9,8 @@ class AggregationTest < Minitest::Test
     expected_sum = numbers.reduce(:+)
 
     # but where's the fun in that...
-    actual_sum = Enzymator::Aggregation.new({
-      null_result:      lambda { 0 },
-      map:              lambda { |n| n },
-      reduce:           lambda { |acum, n, _| acum + n },
+    actual_sum = Enzymator::Aggregations::MapReduce.new({
+      reduction: ->(acum, n) { acum + n }
     }).run_on(numbers)
 
     assert_equal expected_sum, actual_sum
@@ -39,14 +37,10 @@ class AggregationTest < Minitest::Test
       'fat.'    => 1,
     }
 
-    aggregation = Enzymator::Aggregation.new({
-      null_result:      lambda { Hash.new(0) },
-      map:              lambda { |w| w },
-      reduce:           lambda { |acum, w, _| acum[w] += 1; acum }
-    }).run_on!(words)
-    # notice the bang
-
-    actual_hash = aggregation.result
+    actual_hash = Enzymator::Aggregations::MapReduce.new({
+      reduction: ->(acum, w) { acum[w] += 1; acum },
+      empty: Hash.new(0)
+    }).run_on(words)
 
     assert_equal expected_hash, actual_hash
 
@@ -55,10 +49,11 @@ class AggregationTest < Minitest::Test
     expected_hash.delete('The')
     expected_hash = expected_hash.map { |k, v| { k.downcase => v } }.reduce(&:merge)
 
-    aggregation.patch_config( map: lambda { |w| w.downcase } )
-    .run_on!(words)
-
-    actual_hash = aggregation.result
+    actual_hash = Enzymator::Aggregations::MapReduce.new({
+      mapping:   ->(w) { w.downcase },
+      reduction: ->(acum, w) { acum[w] += 1; acum },
+      empty: Hash.new(0)
+    }).run_on(words)
 
     assert_equal expected_hash, actual_hash
 

data/test/transformations/test_application.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestApplication < Minitest::Test
+
+  def test_application
+    object = 26
+    expected = 27
+
+    actual = Enzymator::Transformations::Object::Application.new({
+      function: ->(x) { x + 1 }
+    }).run_on(object)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/transformations/test_join.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestJoin < Minitest::Test
+
+  def test_join
+    ary = [1, 2, [3, 4], [5], [6, [7, 8], 9]]
+    expected = [1, 2, 3, 4, 5, 6, [7, 8], 9]
+    actual = Enzymator::Transformations::Monad::Join.new.run_on(ary)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/transformations/test_mapping.rb

@@ -0,0 +1,16 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestMapping < Minitest::Test
+
+  def test_map
+    ary = (1..9).to_a
+    expected = ary.map { |n| n + 1 }
+    actual = Enzymator::Transformations::Functor::Mapping.new({
+      map: ->(n) { n + 1 }
+    }).run_on(ary)
+
+    assert_equal expected, actual
+  end
+
+end

data/test/transformations/test_reduction.rb

@@ -0,0 +1,69 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class TestReduction < Minitest::Test
+
+  def test_reduction_sum
+    ary = (1..9).to_a
+    expected = (1..9).to_a.reduce(:+)
+
+    actual_explicit = Enzymator::Transformations::Foldable::Reduction.new({
+      append: ->(acum, n) { acum + n }
+    }).run_on(ary)
+
+    actual_implicit = Enzymator::Transformations::Foldable::Reduction.new
+    .run_on(ary)
+
+    assert_equal expected, actual_explicit
+    assert_equal expected, actual_implicit
+  end
+
+  def test_reduction_product
+    ary = (1..9).to_a
+    expected = (1..9).to_a.reduce(:*)
+
+    absorbed = Enzymator::Transformations::Foldable::Reduction.new({
+      append: ->(acum, n) { acum * n }
+    }).run_on(ary)
+
+    actual = Enzymator::Transformations::Foldable::Reduction.new({
+      append: ->(acum, n) { acum * n },
+      empty: 1
+    }).run_on(ary)
+
+    assert_equal 0, absorbed
+    assert_equal expected, actual
+  end
+
+  def test_reduction_concat
+    ary = (1..9).to_a.map { |n| [+n, -n] }
+    expected = (1..9).to_a.map { |n| [+n, -n] }.reduce(:concat).to_a
+
+    actual_explicit = Enzymator::Transformations::Foldable::Reduction.new({
+      append: ->(acum, pair) { acum + pair },
+    }).run_on(ary)
+
+    actual_implicit = Enzymator::Transformations::Foldable::Reduction.new
+    .run_on(ary)
+
+    assert_equal expected, actual_explicit
+    assert_equal expected, actual_implicit
+  end
+
+  def test_reduction_merge
+    hashes = [ { 'a' => 1, 'b' => 2, 'c' => 3 }, { 'd' => 4 }, { 'e' => 5 } ]
+    expected = { 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5 }
+
+    actual_explicit = Enzymator::Transformations::Foldable::Reduction.new({
+      append: ->(acum, pair) { acum.merge pair },
+      empty: { 'f' => 6 }
+    }).run_on(hashes)
+
+    actual_implicit = Enzymator::Transformations::Foldable::Reduction.new
+    .run_on(hashes)
+
+    assert_equal expected.merge({ 'f' => 6 }), actual_explicit
+    assert_equal expected, actual_implicit
+  end
+
+end

metadata

@@ -1,32 +1,105 @@
 --- !ruby/object:Gem::Specification
 name: enzymator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Eugenio Bruno
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-17 00:00:00.000000000 Z
-dependencies: []
-description: A gem to perform any kind of calculation on any kind of data. The essence
-  of MapReduce distilled in a few lines of code for the ruby community to enjoy.
+date: 2016-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: A gem to perform any kind of transformation on any kind of data. The
+  essence of MapReduce distilled in a few lines of code for the ruby community to
+  enjoy.
 email: eugeniobruno@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
 - enzymator.gemspec
 - lib/enzymator.rb
-- lib/enzymator/aggregation.rb
-- lib/enzymator/core_ext/enumerator.rb
+- lib/enzymator/aggregations/average.rb
+- lib/enzymator/aggregations/base.rb
+- lib/enzymator/aggregations/count.rb
+- lib/enzymator/aggregations/mapreduce.rb
+- lib/enzymator/aggregations/merge_hashes.rb
+- lib/enzymator/aggregations/sum.rb
+- lib/enzymator/core_ext/categorizer.rb
+- lib/enzymator/core_ext/monoids.rb
+- lib/enzymator/transformations/base.rb
+- lib/enzymator/transformations/config.rb
+- lib/enzymator/transformations/foldable/reduction.rb
+- lib/enzymator/transformations/functor/mapping.rb
+- lib/enzymator/transformations/monad/join.rb
+- lib/enzymator/transformations/object/application.rb
+- lib/enzymator/transformations/object/pipelining.rb
+- lib/enzymator/transformers/base.rb
+- lib/enzymator/transformers/foldable/simple_reducer.rb
+- lib/enzymator/transformers/functor/simple_mapper.rb
+- lib/enzymator/transformers/monad/simple_joiner.rb
+- lib/enzymator/transformers/object/simple_applicator.rb
+- lib/enzymator/transformers/object/simple_pipeliner.rb
+- lib/enzymator/types/list/foldable/enumerable.rb
+- lib/enzymator/types/list/functor/enumerable.rb
+- lib/enzymator/types/list/monad/array.rb
 - lib/enzymator/version.rb
-- test/test_aggregation.rb
+- test/aggregations/test_average.rb
+- test/aggregations/test_count.rb
+- test/aggregations/test_merge_hashes.rb
+- test/aggregations/test_sum.rb
+- test/test_introduction.rb
+- test/transformations/test_application.rb
+- test/transformations/test_join.rb
+- test/transformations/test_mapping.rb
+- test/transformations/test_reduction.rb
 homepage: http://rubygems.org/gems/enzymator
 licenses:
 - MIT
@@ -39,7 +112,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -52,4 +125,12 @@ signing_key:
 specification_version: 4
 summary: An extremely simple and powerful aggregation framework
 test_files:
-- test/test_aggregation.rb
+- test/aggregations/test_average.rb
+- test/aggregations/test_count.rb
+- test/aggregations/test_merge_hashes.rb
+- test/aggregations/test_sum.rb
+- test/test_introduction.rb
+- test/transformations/test_application.rb
+- test/transformations/test_join.rb
+- test/transformations/test_mapping.rb
+- test/transformations/test_reduction.rb

data/Gemfile.lock

@@ -1,33 +0,0 @@
-PATH
-  remote: .
-  specs:
-    enzymator (0.0.1)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    byebug (9.0.5)
-    coderay (1.1.1)
-    method_source (0.8.2)
-    minitest (5.9.0)
-    pry (0.10.4)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    pry-byebug (3.4.0)
-      byebug (~> 9.0)
-      pry (~> 0.10)
-    rake (11.2.2)
-    slop (3.6.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  enzymator!
-  minitest (~> 5.9)
-  pry-byebug
-  rake (~> 11.2)
-
-BUNDLED WITH
-   1.12.5

data/lib/enzymator/aggregation.rb

@@ -1,63 +0,0 @@
-module Enzymator
-  class Aggregation
-
-    @@single_cluster_config = {
-      initial_clusters: lambda { |n| n },
-      enumerator:       lambda { |n| [n].each },
-      map_each:         lambda { |n| :single_cluster },
-      reduce_each:      lambda { |acum, n| :single_cluster },
-    }
-
-    attr_accessor :config, :results
-
-    def initialize(config, results = [])
-      @config = @@single_cluster_config.merge(config)
-      @results = results
-    end
-
-    def last_result
-      results.last
-    end
-    alias :result :last_result
-
-    def patch_config(config_patch)
-      self.config = config.merge(config_patch)
-      self
-    end
-
-    def run_on!(enumerable, options = {}, config = @config)
-      add_result(run_on(enumerable, options, config))
-      self
-    end
-
-    def run_on(enumerable, options = {}, config = @config)
-      config[:initial_clusters].call(enumerable).reduce(config[:null_result].call) do |acum, cluster|
-        group = config[:map].call(cluster)
-        config[:reduce].call( acum, group, aggregate(cluster, config, options) )
-      end
-    end
-
-    protected
-
-    def add_result(result)
-      @results.push(result)
-      self
-    end
-
-    def aggregate(cluster, config, options)
-      enum             = config[:enumerator].call(cluster)
-      first_element    = enum.peek
-      first_map_result = config[:map_each].call(first_element)
-
-      enum.skip(1).reduce(first_map_result) do |acum, e|
-        step(acum, e, config, options)
-      end
-    end
-
-    def step(previous_result, elem, config, options)
-      map_result = config[:map_each].call(elem)
-      config[:reduce_each].call(previous_result, map_result)
-    end
-
-  end
-end

data/lib/enzymator/core_ext/enumerator.rb

@@ -1,20 +0,0 @@
-class Enumerator
-  #
-  # Skip the first n elements and return an Enumerator for the rest, or pass them
-  # in succession to the block, if given.
-  # Extracted from epitools: https://github.com/epitron/epitools
-  #
-  def skip(n)
-    if block_given?
-      each do |x|
-        if n > 0
-          n -= 1
-        else
-          yield x
-        end
-      end
-    else
-      to_enum(:skip, n)
-    end
-  end
-end