pbatcher 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27467cd06d8e1ccda1be1cd65130b45ed3551ea2
+  data.tar.gz: 79ed28ce7f0459590094e0f305110ee41f9b5885
+SHA512:
+  metadata.gz: 871de621c34980137fc8db0a9720445bd2f75bf6250686a81771f5ed8c9c4211942d6188fc99b36e33bbe1e9ac4e3e4333b136916c00565fe6a0a84cd29a6255
+  data.tar.gz: ec065bb5d3077b15752a225c8c9097c1d72a93a5405d7a9e8abd623ca5c1cb11c54b1973fca566a7b1f80130ec17cc9937e36a6d59e95836fc8a04ba3da438cc

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Contributing
+
+1. Fork this project
+2. Create your feature branch `git checkout -b my-branch`
+3. Add yourself as a developer to `README.md`!
+4. Commit your changes `git commit -am 'Add some feature'`
+5. Push to the branch `git push origin my-new-feature`
+6. Create a pull request with the following format:
+
+```markdown
+## Description
+
+This pull request will be used to [fix|implement|...] the following [bugs|features|...].
+
+## Tasks
+
+- [ ] Uncompleted task nº1.
+- [x] Completed task nº2.
+- [x] Buy eggs.
+- [ ] Fix that strange bug.
+- [ ] Etc.
+
+## References
+
+- [Example reference](http://www.example.com)
+- [Wabit season!](https://www.youtube.com/watch?v=17ocaZb-bGg)
+```
+
+Remember that your help is always appreciated! :smile:

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gem 'colorize'
+
+group :development do
+  gem 'rdoc', '~> 3.12'
+  gem 'bundler', '~> 1.0'
+  gem 'juwelier', '~> 2.1.0'
+  gem 'pry', '~> 0.10.0'
+  gem 'pry-nav', '~> 0.2.0'
+end
+
+group :test do
+  gem 'test-unit', '>= 3.2'
+  gem 'shoulda', '>= 0'
+  gem 'simplecov', '>= 0'
+end

data/Gemfile.lock

@@ -0,0 +1,100 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.4.0)
+    builder (3.2.2)
+    coderay (1.1.1)
+    colorize (0.8.1)
+    concurrent-ruby (1.0.2)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    docile (1.1.5)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    git (1.3.0)
+    github_api (0.14.5)
+      addressable (~> 2.4.0)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.4)
+      oauth2 (~> 1.0)
+    hashie (3.4.6)
+    highline (1.7.8)
+    i18n (0.7.0)
+    json (1.8.3)
+    juwelier (2.1.2)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+      semver
+    jwt (1.5.6)
+    method_source (0.8.2)
+    mini_portile2 (2.1.0)
+    minitest (5.9.1)
+    multi_json (1.12.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.8.1)
+      mini_portile2 (~> 2.1.0)
+    oauth2 (1.2.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    power_assert (0.3.0)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-nav (0.2.4)
+      pry (>= 0.9.10, < 0.11.0)
+    rack (2.0.1)
+    rake (11.3.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    semver (1.0.1)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.1)
+    shoulda-matchers (2.8.0)
+      activesupport (>= 3.0.0)
+    simplecov (0.12.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+    test-unit (3.2.1)
+      power_assert
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  colorize
+  juwelier (~> 2.1.0)
+  pry (~> 0.10.0)
+  pry-nav (~> 0.2.0)
+  rdoc (~> 3.12)
+  shoulda
+  simplecov
+  test-unit (>= 3.2)
+
+BUNDLED WITH
+   1.12.5

data/LICENSE.md

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+=====================
+
+Copyright © `2016` `Daniel Herzog`
+
+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,82 @@
+[![Gem Version](https://badge.fury.io/rb/pbatcher.svg)](https://badge.fury.io/rb/pbatcher) [![Dependency Status](https://gemnasium.com/badges/github.com/wikiti/pbatcher.svg)](https://gemnasium.com/github.com/wikiti/pbatcher) [![CircleCI](https://circleci.com/gh/wikiti/pbatcher.svg?style=shield)](https://circleci.com/gh/wikiti/pbatcher)
+
+# Process Batcher
+
+Process Batcher (or `pbatcher`) is a ruby gem used to build quick CLI apps to process batches of tasks.
+
+This project uses [`juwelier`](https://github.com/flajann2/juwelier) for managing and releasing this gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pbatcher'
+```
+
+And then execute:
+
+```sh
+$ bundle install
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install pbatcher
+```
+
+## Usage
+
+`pbatcher` uses a simple DSL syntax to construct applications.
+
+For example, to create an application that takes an array of numbers, and calculate their double, and take only those
+which are smaller than `30`:
+
+```rb
+require 'pbatcher'
+
+pbatcher do
+  # Define the iterator (data) to process
+  iteration [1, 5, 10, 20]
+
+  # Define the callback to process each item.
+  processing { |x| x * 2 }
+
+  # Validate the processed content
+  # (double of x must be smaller than 30)
+  validation { |x| x < 30 }
+
+  # Name each item for output purposes
+  naming { |x| "nº #{x}" }
+end
+```
+
+This program will output the following:
+
+```
+Processing nº 1      [OK]
+Processing nº 5      [OK]
+Processing nº 10     [OK]
+Processing nº 20     [FAIL]
+```
+
+## Options
+
+The DSL includes the following methods within the `pbatcher` method:
+
+| Method | Description | Argument | Default value |
+| ------ | ----------- | -------- | ------------- |
+| iteration | Data to iterate. Each item will be processed as an unique task. | `Enumerator`, `Proc`, or anything that respond to `:each`. | `[]` |
+| processing | Items handler. A method which is run for each item. Any unhandled exception will result into a `FAIL` | A block, `proc` or a `lambda`. | `->(x) { x }` |
+| validation | Validates the output of `processing` to mark the item as `OK` or `FAIL`. | A block, `proc` or a `lambda`. | `->(x) { true }` |
+| naming | A simple method to given a human-readable name to each item. | A block, `proc` or a `lambda`. | `->(x) { x.to_s }` |
+| logger | A logger item to inform about errors. Can be accessed via `logger` within the `pbatcher` context. | Any object that respond to any method supported by Ruby's `Logger` class. | `Logger.new('pbatcher.log')` |
+
+## Authors
+
+This project has been developed by:
+
+| Avatar | Name | Nickname | Email |
+| ------- | ------------- | --------- | ------------------ |
+| ![](http://www.gravatar.com/avatar/2ae6d81e0605177ba9e17b19f54e6b6c.jpg?s=64)  | Daniel Herzog | Wikiti | [info@danielherzog.es](mailto:info@danielherzog.es) |

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
+  gem.name = "pbatcher"
+  gem.homepage = "http://github.com/wikiti/pbatcher"
+  gem.license = "MIT"
+  gem.summary = %Q{A simple library to create CLI batch applications.}
+  gem.description = %Q{Process Batcher (or `pbatcher`) is a ruby gem used to build quick CLI apps to process batches of tasks.}
+  gem.email = "info@danielherzog.es"
+  gem.authors = ["Daniel Herzog"]
+end
+Juwelier::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pbatcher #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/pbatcher/generator.rb

@@ -0,0 +1,54 @@
+module PBatcher
+  class Generator
+    attr_reader :iterator, :processor, :validator, :namer, :logger
+
+    def self.build(&block)
+      obj = new
+      obj.instance_eval(&block) if block_given?
+      obj.run
+      obj
+    end
+
+    def initialize
+
+    end
+
+    def run
+      setup_default_handlers
+      logger.info '------------------------------------'
+      iterator.iterate { |item| processor.process item }
+    end
+
+    def naming(l = nil, &block)
+      @namer = Namer.new self, l || block
+    end
+
+    def validation(l = nil, &block)
+      @validator = Validator.new self, l || block
+    end
+
+    def iteration(data)
+      @iterator = Iterator.new self, data
+    end
+
+    def processing(l = nil, &block)
+      @processor = Processor.new self, l || block
+    end
+
+    def logging(logger)
+      @logger = logger
+    end
+
+    private
+
+    def setup_default_handlers
+      @iterator ||= Iterator.new self, []
+      @validator ||= Validator.new self, ->(item) { true }
+      @namer ||= Namer.new self, ->(item) { item.to_s }
+      @processor ||= Processor.new self, ->(item) { item }
+      @logger ||= ::Logger.new('pbatcher.log')
+    end
+
+    # ...
+  end
+end

data/lib/pbatcher/handler.rb

@@ -0,0 +1,9 @@
+module PBatcher
+  class Handler
+    attr_reader :generator
+
+    def initialize(generator)
+      @generator = generator
+    end
+  end
+end

data/lib/pbatcher/iterator.rb

@@ -0,0 +1,29 @@
+module PBatcher
+  class Iterator < Handler
+    attr_reader :data
+
+    def initialize(generator, data)
+      super(generator)
+      @data = data
+    end
+
+    def iterate(&block)
+      iterator.each(&block)
+    end
+
+    private
+
+    def iterator
+      case data
+      when Enumerator
+        data
+      when Proc
+        data.call()
+      when ->(data) { data.respond_to? :each }
+        data
+      else
+        raise NotImplementedError, "Data type cannot be handled because it doesn't respond to :each."
+      end
+    end
+  end
+end

data/lib/pbatcher/namer.rb

@@ -0,0 +1,7 @@
+module PBatcher
+  class Namer < ProcHandler
+    def name(item)
+      call(item)
+    end
+  end
+end

data/lib/pbatcher/printer.rb

@@ -0,0 +1,45 @@
+module PBatcher
+  module Printer
+    extend self
+
+    SUCCESS_MESSAGE = "OK".green.freeze
+    FAILURE_MESSAGE = "FAIL".red.freeze
+
+    OVERFLOW = '...'
+
+    def message(str, options = { max_size: 90 })
+      print message_str(str, options)
+    end
+
+    def success
+      print "[#{SUCCESS_MESSAGE}]"
+    end
+
+    def failure
+      print "[#{FAILURE_MESSAGE}]"
+    end
+
+    def newline
+      puts ''
+    end
+
+    private
+
+    def message_str(str, options)
+      return message_str_overflow(str, options) if message_str_overflow?(str, options)
+      message_str_normal(str, options)
+    end
+
+    def message_str_overflow(str, options)
+      str[0...(options[:max_size] - OVERFLOW.size)] + OVERFLOW
+    end
+
+    def message_str_normal(str, options)
+      str.ljust options[:max_size]
+    end
+
+    def message_str_overflow?(str, options)
+      str.size > options[:max_size] - OVERFLOW.size
+    end
+  end
+end

data/lib/pbatcher/proc_handler.rb

@@ -0,0 +1,16 @@
+module PBatcher
+  class ProcHandler < Handler
+    attr_reader :method
+
+    def initialize(generator, method = nil, &block)
+      super(generator)
+      method = method ? method : block
+      raise ArgumentError, 'Namer is not a proc' unless method.is_a? Proc
+      @method = method || block
+    end
+
+    def call(*args)
+      method.call(*args)
+    end
+  end
+end

data/lib/pbatcher/processor.rb

@@ -0,0 +1,33 @@
+module PBatcher
+  class Processor < ProcHandler
+    def process(item)
+      pre(item)
+      result = call(item)
+      raise "Item #{item} is not a valid item." unless generator.validator.valid?(result)
+      success(item)
+      result
+    rescue => e
+      failure(item, e)
+    end
+
+    private
+
+    def pre(item)
+      Printer.message "Processing #{generator.namer.name item}"
+      generator.logger.info "Processing #{generator.namer.name item}"
+    end
+
+    def success(item)
+      Printer.success
+      Printer.newline
+      generator.logger.info "Processed #{generator.namer.name item}"
+    end
+
+    def failure(item, exception)
+      Printer.failure
+      Printer.newline
+      generator.logger.error "Error while processing #{generator.namer.name item}: #{exception}"
+    end
+
+  end
+end

data/lib/pbatcher/validator.rb

@@ -0,0 +1,9 @@
+module PBatcher
+  class Validator < ProcHandler
+    attr_reader :method
+
+    def valid?(result)
+      !!method.call(result)
+    end
+  end
+end

data/lib/pbatcher.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+require 'colorize'
+
+require 'pbatcher/printer'
+require 'pbatcher/handler'
+require 'pbatcher/proc_handler'
+require 'pbatcher/processor'
+require 'pbatcher/validator'
+require 'pbatcher/namer'
+require 'pbatcher/iterator'
+require 'pbatcher/generator'
+
+def pbatcher(&block)
+  PBatcher::Generator.build(&block)
+end

data/test/helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts 'Run `bundle install` to install missing gems'
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'pbatcher'
+
+class Test::Unit::TestCase
+  def capture_stdout
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    yield
+    fake.string
+  ensure
+    $stdout = original_stdout
+  end
+
+  def nil_pbatcher
+    pbatcher
+  end
+
+  def pbatcher_example
+    output = nil
+    capture_stdout do
+      output = pbatcher do
+        # Define the iterator (data) to process
+        iteration [1, 5, 10, 20]
+
+        # Define the callback to process each item.
+        processing { |x| x * 2 }
+
+        # Validate the processed content
+        # (double of x must be smaller than 30)
+        validation { |x| x < 30 }
+
+        # Name each item for output purposes
+        naming { |x| "nº #{x}" }
+      end
+    end
+    output
+  end
+end

data/test/test_generator.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+class TestGenerator < Test::Unit::TestCase
+  context 'creating an empty generator' do
+    should 'has all handlers' do
+      @generator = PBatcher::Generator.build
+
+      assert !@generator.logger.nil?
+      assert !@generator.processor.nil?
+      assert !@generator.namer.nil?
+      assert !@generator.validator.nil?
+      assert !@generator.iterator.nil?
+    end
+  end
+
+  context 'creating a complete generator' do
+    should 'be iterable' do
+      @generator = pbatcher_example
+
+      assert !@generator.logger.nil?
+      assert !@generator.processor.nil?
+      assert !@generator.namer.nil?
+      assert !@generator.validator.nil?
+      assert !@generator.iterator.nil?
+    end
+  end
+end

data/test/test_iterator.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestIterator < Test::Unit::TestCase
+  context 'creating an iterator with an array' do
+    should 'be iterable' do
+      @iterator = PBatcher::Iterator.new nil, [1, 2, 3]
+      assert @iterator.iterate.is_a?(Enumerator)
+    end
+  end
+
+  context 'creating an iterator with an enumerable' do
+    should 'be iterable' do
+      @iterator = PBatcher::Iterator.new nil, (1..3)
+      assert @iterator.iterate.is_a?(Enumerator)
+    end
+  end
+
+  context 'creating an iterator with a block' do
+    should 'be iterable' do
+      @iterator = PBatcher::Iterator.new nil, -> { (1..3) }
+      assert @iterator.iterate.is_a?(Enumerator)
+    end
+  end
+
+  context 'creating an iterator with a block' do
+    should 'not be iterable' do
+      @iterator = PBatcher::Iterator.new nil, -> { nil }
+      assert_raise do
+        @iterator.iterate
+      end
+    end
+  end
+end

data/test/test_logger.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class TestValidator < Test::Unit::TestCase
+  context 'creating a cli application' do
+    should 'be a valid logger' do
+      @pbatcher = nil_pbatcher
+      %i(debug error fatal log warn).each do |method|
+        assert @pbatcher.logger.respond_to?(method)
+      end
+    end
+  end
+end

data/test/test_namer.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class TestNamer < Test::Unit::TestCase
+  context 'creating a namer with a block' do
+    should 'return the representation of the item' do
+      @namer = PBatcher::Namer.new(nil_pbatcher) { |x| "-#{x}-" }
+      assert_equal @namer.name(3), "-3-"
+    end
+  end
+
+  context 'creating a namer with a proc' do
+    should 'return the representation of the item' do
+      @namer = PBatcher::Namer.new nil_pbatcher, ->(x) { "-#{x}-" }
+      assert_equal @namer.name(3), "-3-"
+    end
+  end
+end

data/test/test_pbatcher.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+class TestPBatcher < Test::Unit::TestCase
+  context 'creating a simple CLI application' do
+    should 'not raise errors' do
+      assert_nothing_raised do
+        pbatcher_example
+      end
+    end
+  end
+end

data/test/test_printer.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+class TestPrinter < Test::Unit::TestCase
+  context 'priting success' do
+    should 'print to stdout' do
+      stdout = capture_stdout { PBatcher::Printer.success }
+      assert_equal stdout, "[#{PBatcher::Printer::SUCCESS_MESSAGE}]"
+    end
+  end
+
+  context 'priting failure' do
+    should 'print to stdout' do
+      stdout = capture_stdout { PBatcher::Printer.failure }
+      assert_equal stdout, "[#{PBatcher::Printer::FAILURE_MESSAGE}]"
+    end
+  end
+
+  context 'priting message without overflow' do
+    should 'print to stdout' do
+      stdout = capture_stdout { PBatcher::Printer.message 'Message' }
+      assert_match /^Message\s+$/, stdout
+    end
+  end
+
+  context 'priting message with overflow' do
+    should 'print to stdout' do
+      max_size = 100
+      str = 'a' * max_size
+      stdout = capture_stdout { PBatcher::Printer.message str, max_size: max_size }
+      assert_not_equal stdout, str
+      assert_match /\.\.\.$/, stdout
+    end
+  end
+
+  context 'priting newline' do
+    should 'print to stdout' do
+      stdout = capture_stdout { PBatcher::Printer.newline }
+      assert_match /^\r?\n$/, stdout
+    end
+  end
+end

data/test/test_processor.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class TestProcessor < Test::Unit::TestCase
+  context 'creating a processor with a block' do
+    should 'return the processed value' do
+      @processor = PBatcher::Processor.new(nil_pbatcher) { |x| x * 2 }
+      value = nil
+      capture_stdout { value = @processor.process(3) }
+      assert_equal value, 3 * 2
+    end
+  end
+
+  context 'creating a processor with a proc' do
+    should 'return the processed value' do
+      @processor = PBatcher::Processor.new nil_pbatcher, ->(x) { x * 2 }
+      value = nil
+      capture_stdout { value = @processor.process(3) }
+      assert_equal value, 3 * 2
+    end
+  end
+end

data/test/test_validator.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestValidator < Test::Unit::TestCase
+  context 'creating a validator with a block' do
+    should 'validate properly' do
+      @validator = PBatcher::Validator.new(nil_pbatcher) { |x| x.odd? }
+      assert @validator.valid?(3)
+      assert !@validator.valid?(2)
+    end
+  end
+
+  context 'creating a validator with a proc' do
+    should 'validate properly' do
+      @validator = PBatcher::Validator.new nil_pbatcher, ->(x) { x.odd? }
+      assert @validator.valid?(3)
+      assert !@validator.valid?(2)
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: pbatcher
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Herzog
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: juwelier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Process Batcher (or `pbatcher`) is a ruby gem used to build quick CLI
+  apps to process batches of tasks.
+email: info@danielherzog.es
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.md
+- README.md
+files:
+- ".document"
+- CONTRIBUTING.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- VERSION
+- lib/pbatcher.rb
+- lib/pbatcher/generator.rb
+- lib/pbatcher/handler.rb
+- lib/pbatcher/iterator.rb
+- lib/pbatcher/namer.rb
+- lib/pbatcher/printer.rb
+- lib/pbatcher/proc_handler.rb
+- lib/pbatcher/processor.rb
+- lib/pbatcher/validator.rb
+- test/helper.rb
+- test/test_generator.rb
+- test/test_iterator.rb
+- test/test_logger.rb
+- test/test_namer.rb
+- test/test_pbatcher.rb
+- test/test_printer.rb
+- test/test_processor.rb
+- test/test_validator.rb
+homepage: http://github.com/wikiti/pbatcher
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A simple library to create CLI batch applications.
+test_files: []