enzymator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2ec2a4060b6cda9e9556c05b4feb7f8188b91ed
+  data.tar.gz: 5c01a79eed612fc1c63a7a496695ef5898e7f38f
+SHA512:
+  metadata.gz: 0d7e5533db3223a545e7c175f3ffe65fa33e3d3e18c7469b1d2dd129a604fd386db91666120d8ea19d14149b7636dcfbe76c57478513bcad707a0d8ad8dc4592
+  data.tar.gz: f7200cc635e0c058d54fa50d8d28593b366f7ea5e61439d4b9c8d81e264b04ffe3a2574c12f79b369af35725707c13643806e85ac9c2c82b47b42ca4a2e25967

data/Gemfile

@@ -0,0 +1,10 @@
+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/Gemfile.lock

@@ -0,0 +1,33 @@
+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/README.md

@@ -0,0 +1,31 @@
+# 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!
+
+You should take two minutes to check out the test examples.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'enzimator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install enzimator
+
+## Usage
+
+You set up a new Aggregation instance, tell it to run with your Enumerator, and get the result. The tests are self-explanatory.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/enzymator.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'enzymator/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'enzymator'
+  s.version     = Enzymator::Version
+  s.date        = '2016-07-17'
+  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.authors     = ["Eugenio Bruno"]
+  s.email       = 'eugeniobruno@gmail.com'
+  s.homepage    = 'http://rubygems.org/gems/enzymator'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+end

data/lib/enzymator.rb

@@ -0,0 +1,2 @@
+require 'enzymator/core_ext/enumerator'
+require 'enzymator/aggregation'

data/lib/enzymator/aggregation.rb

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,20 @@
+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

data/lib/enzymator/version.rb

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

data/test/test_aggregation.rb

@@ -0,0 +1,67 @@
+require 'minitest/autorun'
+require 'enzymator'
+
+class AggregationTest < Minitest::Test
+
+  def test_sum_numbers
+    numbers = (1..1000).to_a
+    # to sum the numbers, you can just do
+    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 },
+    }).run_on(numbers)
+
+    assert_equal expected_sum, actual_sum
+  end
+
+  def test_count_words
+    # Let's follow the herd of MapReduce preachers and count some words.
+    words = %w(Hey! Are you the horse from Horsing Around? The word is you got fat.)
+
+    # There is no built-in one-message-one-argument way this time...
+    expected_hash = {
+      'Hey!'    => 1,
+      'Are'     => 1,
+      'you'     => 2,
+      'the'     => 1,
+      'horse'   => 1,
+      'from'    => 1,
+      'Horsing' => 1,
+      'Around?' => 1,
+      'The'     => 1,
+      'word'    => 1,
+      'is'      => 1,
+      'got'     => 1,
+      '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
+
+    assert_equal expected_hash, actual_hash
+
+    # I'm thinking 'the' and 'The' should count as one word. Total case-insensitivity
+    expected_hash['the'] = 2
+    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
+
+    assert_equal expected_hash, actual_hash
+
+  end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: enzymator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+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.
+email: eugeniobruno@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- enzymator.gemspec
+- lib/enzymator.rb
+- lib/enzymator/aggregation.rb
+- lib/enzymator/core_ext/enumerator.rb
+- lib/enzymator/version.rb
+- test/test_aggregation.rb
+homepage: http://rubygems.org/gems/enzymator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: An extremely simple and powerful aggregation framework
+test_files:
+- test/test_aggregation.rb