bulk_operations 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a37693a3df12e721c5a22d877a255e208d4a660
+  data.tar.gz: af561b97f29cc392e802ff410e952f79dc41cbf7
+SHA512:
+  metadata.gz: 413659d4f53217baca7341fbde19c3a6727d29bf932c233f20078dd56f2d0b97bf011545f832a3ecbceb940767a092fa3b284c479a418b0d7a407492ec1aec13
+  data.tar.gz: 98d6c793c074b0bd205c45fe84f9b1e8f2ea45c5306a05c2a8789b8ea106f00bdc57ecabc8581b520f7e104f8300f5d2ed9affce756dd71b48d237fda82b6fa5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+bulk_operations

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.1.2"
+  - "jruby-1.7.12"

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bulk_methods.gemspec
+gemspec
+
+group :test do
+  gem 'minitest-ansi'
+end
+
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jorge Luis Pérez
+
+MIT License
+
+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

@@ -0,0 +1,77 @@
+# BulkOperations
+
+[![Build Status](https://travis-ci.org/jolisper/bulk_operations.svg?branch=master)](https://travis-ci.org/jolisper/bulk_operations)
+
+Run your objects methods in a multi-threaded and bulked way.
+
+## Motivation
+You want to define different operations in a single object and you want to run them as a bulk and in a unordered (asynchronous) way. Also, you want to run them as a sequence, in the same order you called them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bulk_operations'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bulk_operations
+
+## Usage
+
+First define the class of your object:
+```ruby
+class MyObject
+  def operation_1
+    # operation_1 code goes here
+  end
+
+  def operation_2
+    # operation_2 code goes here
+  end	
+end	
+```
+
+Then wrap your object in a bulk:
+
+```ruby
+require 'bulk_operations'
+
+bulk = BulkOperations.unordered_bulk( MyObject.new )
+```
+
+Call your methods object through the bulk:
+
+```ruby
+bulk.operation_1
+bulk.operation_2
+```
+
+The methods doesn't run immediately, you need to execute the bulk to run them:
+```ruby
+operations = bulk.execute
+```
+
+Through the `operations` object you can ask if a particular operation finished OK, and get the result of this operation:
+
+```ruby
+operations.operation_1.ok #=> returns true or false
+operations.operation_1.result  #=> returns the result or the raised exception
+```
+
+## Considerations about shared mutable state
+
+Bulks doesn't care about the shared mutable state between your operations (at least in this version). So, if your operations share mutable state and you are using an unordered bulk, please add the necessary locks. 
+
+## 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,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => [:spec]
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/*_spec.rb']
+end

data/benchmark/main.rb

@@ -0,0 +1,118 @@
+$:.push File.expand_path("../../lib", __FILE__)
+
+require 'bulk_operations'
+require 'benchmark'
+require 'yaml'
+
+class MyOperations
+  def yaml_to_object(yaml)
+    YAML.load(yaml)
+  end
+
+  def object_to_yaml(object)
+    object.to_yaml
+  end
+
+  def yaml_to_object2(yaml)
+    YAML.load(yaml)
+  end
+
+  def object_to_yaml2(object)
+    object.to_yaml
+  end
+
+  def yaml_to_object3(yaml)
+    YAML.load(yaml)
+  end
+
+  def object_to_yaml3(object)
+    object.to_yaml
+  end
+
+  def yaml_to_object4(yaml)
+    YAML.load(yaml)
+  end
+
+  def object_to_yaml4(object)
+    object.to_yaml
+  end
+
+  def yaml_to_object5(yaml)
+    YAML.load(yaml)
+  end
+
+  def object_to_yaml5(object)
+    object.to_yaml
+  end
+
+end
+
+class MyObject
+  attr_accessor :attr1, :attr2, :attr3
+  
+  def initialize(attr1=1, attr2=2, attr3=3)
+    @attr1 = attr1
+    @attr2 = attr2
+    @attr3 = attr3
+  end
+end
+
+## Ordered Bulk
+my_object = MyObject.new
+
+ordered_bulk = BulkOperations.ordered_bulk(MyOperations.new)
+
+ordered_bulk.yaml_to_object(my_object.to_yaml)
+ordered_bulk.object_to_yaml(my_object)
+ordered_bulk.yaml_to_object2(my_object.to_yaml)
+ordered_bulk.object_to_yaml2(my_object)
+ordered_bulk.yaml_to_object3(my_object.to_yaml)
+ordered_bulk.object_to_yaml3(my_object)
+ordered_bulk.yaml_to_object4(my_object.to_yaml)
+ordered_bulk.object_to_yaml4(my_object)
+ordered_bulk.yaml_to_object5(my_object.to_yaml)
+ordered_bulk.object_to_yaml5(my_object)
+
+## Unordered Bulk
+my_object = MyObject.new
+
+unordered_bulk = BulkOperations.unordered_bulk(MyOperations.new)
+
+unordered_bulk.yaml_to_object(my_object.to_yaml)
+unordered_bulk.object_to_yaml(my_object)
+unordered_bulk.yaml_to_object2(my_object.to_yaml)
+unordered_bulk.object_to_yaml2(my_object)
+unordered_bulk.yaml_to_object3(my_object.to_yaml)
+unordered_bulk.object_to_yaml3(my_object)
+unordered_bulk.yaml_to_object4(my_object.to_yaml)
+unordered_bulk.object_to_yaml4(my_object)
+ordered_bulk.yaml_to_object5(my_object.to_yaml)
+ordered_bulk.object_to_yaml5(my_object)
+
+bench_mark = Proc.new do |cant_objects|
+  puts "----------------------------------------"
+  puts "Marshall/Unmarshall #{cant_objects} objects\n\n"
+
+  Benchmark.bm(15) do |b|
+    b.report("Ordered Bulk") do
+      cant_objects.times { ordered_bulk.execute } 
+    end
+    
+    b.report("Unordered Bulk") do
+      cant_objects.times { unordered_bulk.execute } 
+    end
+  end
+
+  puts "----------------------------------------\n"
+end
+
+# Rehersal
+bench_mark.call 1_000
+
+
+## Benchmarks
+5.times do |i|
+  bench_mark.call 1_000 * (i + 1)  
+end
+
+

data/bulk_operations.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bulk_operations/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bulk_operations"
+  spec.version       = BulkOperations::VERSION
+  spec.authors       = ["Jorge Luis Pérez"]
+  spec.email         = ["jolisper@gmail.com"]
+  spec.description   = %q{Run your objects methods in a multithreaded and bulked way}
+  spec.summary       = %q{Motivation: you want to define different operations in a single object and you want to run them as a bulk and in a unordered (asynchronous) way. Also, you want to run them as a sequence, in the same order you called them.}
+  spec.homepage      = "https://github.com/jolisper/bulk_operations"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/bulk_operations.rb

@@ -0,0 +1,17 @@
+require "bulk_operations/version"
+require "bulk_operations/proxy"
+require "bulk_operations/ordered_bulk"
+require "bulk_operations/unordered_bulk"
+require "bulk_operations/struct_result"
+
+module BulkOperations
+  
+  def self.unordered_bulk(object)
+    UnorderedBulkProxy.new(object)
+  end
+
+  def self.ordered_bulk(object)
+    OrderedBulkProxy.new(object)
+  end
+
+end

data/lib/bulk_operations/ordered_bulk.rb

@@ -0,0 +1,31 @@
+module BulkOperations
+  class OrderedBulkProxy < BulkProxy
+    def do_execute
+      result = Hash.new
+      fibers = []
+
+      @operation_stack.each do |operation|
+        name, *args, block = *operation
+        fibers << create_fiber(name, args, block, result)
+      end
+
+      fibers.each(&:resume)
+
+      StructResult.new result
+    end
+
+    def create_fiber(name, args, block, result)
+      fiber = Fiber.new do
+        begin
+          call_result = @proxied_object.__send__(name, *args, &block)
+          result[name] = { ok: true, result: call_result }
+        rescue => exception
+          result[name] = { ok: false, result: exception }
+        end
+      end
+
+      fiber
+    end
+
+  end
+end

data/lib/bulk_operations/proxy.rb

@@ -0,0 +1,33 @@
+module BulkOperations
+
+  class OperationStackEmptyError < StandardError; end
+
+  class BulkProxy
+    attr_reader :proxied_object
+
+    def initialize(object)	
+      @proxied_object = object
+      @operation_stack = []
+    end
+
+    def method_missing(name, *args, &block)
+      @operation_stack << [name, *args, block]
+    end
+
+    def execute
+      raise OperationStackEmptyError if @operation_stack.empty?
+      do_execute
+    end
+
+  end
+
+end
+
+
+
+
+
+
+
+
+

data/lib/bulk_operations/struct_result.rb

@@ -0,0 +1,24 @@
+require 'ostruct'
+
+module BulkOperations
+  class StructResult < OpenStruct
+    def initialize(hash=nil)
+      @table = {}
+      @hash_table = {}
+
+      if hash
+        hash.each do |k,v|
+          @table[k.to_sym] = (v.is_a?(Hash) ? self.class.new(v) : v)
+          @hash_table[k.to_sym] = v
+
+          new_ostruct_member(k)
+        end
+      end
+    end
+
+    def to_h
+      @hash_table
+    end
+
+  end
+end

data/lib/bulk_operations/unordered_bulk.rb

@@ -0,0 +1,31 @@
+module BulkOperations
+  class UnorderedBulkProxy < BulkProxy
+    def do_execute
+      result = Hash.new
+      threads = []
+
+      @operation_stack.each do |operation|
+        name, *args, block = *operation
+        threads << spawn_thread(name, args, block, result)
+      end
+
+      threads.each(&:join)
+
+      StructResult.new result
+    end
+
+    def spawn_thread(name, args, block, result)
+      thread = Thread.new do
+        begin
+          call_result = @proxied_object.__send__(name, *args, &block)
+          result[name] = { ok: true, result: call_result }
+        rescue => exception
+          result[name] = { ok: false, result: exception }
+        end
+      end
+
+      thread
+    end
+
+  end
+end

data/lib/bulk_operations/version.rb

@@ -0,0 +1,3 @@
+module BulkOperations
+  VERSION = "0.1.0"
+end

data/spec/module_methods_spec.rb

@@ -0,0 +1,12 @@
+require_relative './spec_helper.rb'
+
+describe BulkOperations do
+
+  describe "::unorderedBulk(object)" do
+    it "returns a BulkOperations::UnorderedBulkProxy" do
+      proxy = BulkOperations.unordered_bulk(Object.new)
+      proxy.must_be_instance_of BulkOperations::UnorderedBulkProxy
+    end
+  end
+
+end

data/spec/ordered_bulk_spec.rb

@@ -0,0 +1,79 @@
+require_relative './spec_helper.rb'
+require_relative './proxied_object.rb'
+
+describe BulkOperations::OrderedBulkProxy do
+
+  describe "#proxied_object" do
+
+    before do
+      @bulked = ProxiedObject.new
+      @bulk   = BulkOperations.ordered_bulk(@bulked)
+    end
+
+    it "returns the proxied object" do
+      @bulk.instance_variable_get("@proxied_object").must_equal(@bulked)
+    end
+
+    describe "when a method is called on a bulk proxy" do
+      it "the method call is added to the stack" do
+        @bulk.test_method(:param) { :block }
+        call_stack = @bulk.instance_variable_get("@operation_stack")
+        call_stack.size.must_equal 1
+      end
+    end
+
+  end
+  
+  describe "#execute" do
+    describe "when the method stack is empty" do
+      let(:bulk) { BulkOperations.ordered_bulk(Object.new) }
+
+      it "raise OperationStackEmptyError" do
+        lambda { bulk.execute }.must_raise BulkOperations::OperationStackEmptyError
+      end
+
+    end
+
+    describe "when the stack is NOT empty" do
+      before do
+        @bulk = BulkOperations.ordered_bulk(ProxiedObject.new)
+        @bulk.operation_1
+      end
+
+      it "returns a hash with the results of operation executions" do
+        @bulk.execute.must_be_instance_of BulkOperations::StructResult
+      end
+
+      it "the result hash has for the operation has ok: = true" do
+        result = @bulk.execute
+        result.operation_1.ok.must_equal true
+      end
+
+      it "the result hash has for the operation has ok: = true" do
+        result = @bulk.execute
+        result.operation_1.result.must_equal 2
+      end
+
+    end
+
+    describe "when an operation raise an exception" do
+      before do
+        @bulk = BulkOperations.ordered_bulk(ProxiedObject.new)
+        @bulk.raise_exception
+      end
+
+      it "the result hash has for the operation has ok: = false" do
+        result = @bulk.execute
+        result.raise_exception.ok.must_equal false
+      end
+
+      it "the result hash has for the exception throwed" do
+        result = @bulk.execute
+        result.raise_exception.result.must_be_instance_of StandardError
+      end
+
+    end
+
+  end
+
+end

data/spec/proxied_object.rb

@@ -0,0 +1,13 @@
+class ProxiedObject
+  def operation_1
+    2
+  end
+  
+  def operation_2
+  end
+
+  def raise_exception
+    raise StandardError
+  end
+
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,79 @@
+require_relative './spec_helper.rb'
+require_relative './proxied_object.rb'
+
+describe BulkOperations::UnorderedBulkProxy do
+
+  describe "#proxied_object" do
+
+    before do
+      @bulked = ProxiedObject.new
+      @bulk   = BulkOperations.unordered_bulk(@bulked)
+    end
+
+    it "returns the proxied object" do
+      @bulk.instance_variable_get("@proxied_object").must_equal(@bulked)
+    end
+
+    describe "when a method is called on a bulk proxy" do
+      it "the method call is added to the stack" do
+        @bulk.test_method(:param) { :block }
+        call_stack = @bulk.instance_variable_get("@operation_stack")
+        call_stack.size.must_equal 1
+      end
+    end
+
+  end
+  
+  describe "#execute" do
+    describe "when the method stack is empty" do
+      let(:bulk) { BulkOperations.unordered_bulk(Object.new) }
+
+      it "raise OperationStackEmptyError" do
+        lambda { bulk.execute }.must_raise BulkOperations::OperationStackEmptyError
+      end
+
+    end
+
+    describe "when the stack is NOT empty" do
+      before do
+        @bulk = BulkOperations.unordered_bulk(ProxiedObject.new)
+        @bulk.operation_1
+      end
+
+      it "returns a hash with the results of operation executions" do
+        @bulk.execute.must_be_instance_of BulkOperations::StructResult
+      end
+
+      it "the result hash has for the operation has ok: = true" do
+        result = @bulk.execute
+        result.operation_1.ok.must_equal true
+      end
+
+      it "the result hash has for the operation has ok: = true" do
+        result = @bulk.execute
+        result.operation_1.result.must_equal 2
+      end
+
+    end
+
+    describe "when an operation raise an exception" do
+      before do
+        @bulk = BulkOperations.unordered_bulk(ProxiedObject.new)
+        @bulk.raise_exception
+      end
+
+      it "the result hash has for the operation has ok: = false" do
+        result = @bulk.execute
+        result.raise_exception.ok.must_equal false
+      end
+
+      it "the result hash has for the exception throwed" do
+        result = @bulk.execute
+        result.raise_exception.result.must_be_instance_of StandardError
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'bulk_operations'
+
+begin
+  require 'minitest/ansi'
+  MiniTest::ANSI.use!
+rescue LoadError
+end
+
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: bulk_operations
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jorge Luis Pérez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Run your objects methods in a multithreaded and bulked way
+email:
+- jolisper@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/main.rb
+- bulk_operations.gemspec
+- lib/bulk_operations.rb
+- lib/bulk_operations/ordered_bulk.rb
+- lib/bulk_operations/proxy.rb
+- lib/bulk_operations/struct_result.rb
+- lib/bulk_operations/unordered_bulk.rb
+- lib/bulk_operations/version.rb
+- spec/module_methods_spec.rb
+- spec/ordered_bulk_spec.rb
+- spec/proxied_object.rb
+- spec/proxy_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jolisper/bulk_operations
+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.2.2
+signing_key: 
+specification_version: 4
+summary: 'Motivation: you want to define different operations in a single object and
+  you want to run them as a bulk and in a unordered (asynchronous) way. Also, you
+  want to run them as a sequence, in the same order you called them.'
+test_files:
+- spec/module_methods_spec.rb
+- spec/ordered_bulk_spec.rb
+- spec/proxied_object.rb
+- spec/proxy_spec.rb
+- spec/spec_helper.rb