processor 0.0.0.initial → 0.0.1

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Alexander Paramonov
+Copyright (c) 2013 Alexander Paramonov
 
 MIT License
 

data/README.md

@@ -8,9 +8,10 @@ Universal processor for data migration
 Contents
 ---------
 1. Installation
-1. Contributing
 1. Requirements
+1. Usage
 1. Compatibility
+1. Contributing
 1. Copyright
 
 Installation
@@ -35,9 +36,40 @@ gem install processor
 
 Requirements
 ------------
-none
+1. Ruby 1.9
+1. Rspec2 for testing
+
+Usage
+------------
+1. Implement a `DataProcessor`. See `Processor::Example::Migration`, `Processor::Example::SolrMigration`, `Processor::Example::SolrPagesMigration`
+1. Run your `DataProcessor`:
+
+``` ruby
+thread = Processor::Thread.new data_processor
+thread.run_successive
+```
+See `spec/processor/thread_spec.rb` and `spec/example_spec.rb` and `example` directory for other usage examples.  
+Below are specs for most valuable parts of the gem.
+
+``` rspec
+Processor::Thread
+  should run a migration using provided block
+  should run a migration successive
+  should run a migration in threads
 
-rspec2 for testing
+Processor::DataProcessor
+  should have a name equals to underscored class name
+  should be done when there are 0 records to process
+  should respond to done?
+  should respond to fetch_records
+  should respond to total_records
+  should respond to process
+
+Processor::Observer::Logger
+  accepts logger builder as parameter
+  accepts logger as parameter
+  use ruby Logger if no external logger provided
+```
 
 Compatibility
 -------------

data/example/logging_thread.rb

@@ -0,0 +1,15 @@
+require 'processor/thread'
+require 'processor/observer/logger'
+
+module Processor
+  module Example
+    class LoggingThread < Processor::Thread
+      def initialize(processor)
+        super(
+          processor,
+          Processor::Observer::Logger.new
+        )
+      end
+    end
+  end
+end

data/example/migration.rb

@@ -0,0 +1,29 @@
+require 'processor/data_processor'
+
+module Processor
+  module Example
+    class Migration < DataProcessor
+      attr_reader :records
+      def initialize(records)
+        @records = records
+      end
+
+      def done?(records)
+        records.count < 1
+      end
+
+      def process(record)
+        record.do_something
+        "OK"
+      end
+
+      def fetch_records
+        records.shift(2)
+      end
+
+      def total_records
+        records.count
+      end
+    end
+  end
+end

data/example/migrator.rb

@@ -0,0 +1,66 @@
+require 'processor/thread'
+require 'processor/observer/logger'
+
+module Processor
+  module Example
+    class Migrator < Processor::Thread
+      def migrate
+        messenger.info "Migrator start migrating a records one by one at #{Time.now}"
+        run_successive
+      end
+
+      def initialize(migration)
+        # logger could be an instance of Ruby Logger
+        logger1 = ::Logger.new(STDOUT).tap do |logger|
+          logger.formatter =  -> _, _, _, msg do
+            "debug\t< #{msg}\n"
+          end
+          logger.level = ::Logger::DEBUG
+        end
+
+        # Logger could be a lambda
+        # Where "name" is a processor.name
+        logger2 = -> name do
+          ::Logger.new(STDOUT).tap do |logger|
+            logger.formatter =  -> _, _, _, msg do
+              "info\t< #{msg}\n"
+            end
+            logger.level = ::Logger::INFO
+          end
+        end
+
+        # logger could be an instance of Rails Logger
+        # logger = Rails.logger
+        # Or be nil
+        # logger = nil
+        # in this case logger will be initialized as Ruby Logger and write to log/name_of_processor_time_stamp.log
+
+        # You may customize a messenger:
+        messenger = ::Logger.new(STDOUT).tap do |logger|
+          logger.formatter =  -> _, _, _, msg do
+            "message\t> #{msg}\n"
+          end
+          logger.level = ::Logger::DEBUG
+        end
+
+        stdout_logger_debug = Processor::Observer::Logger.new(logger1, messenger: messenger)
+        stdout_logger_info = Processor::Observer::Logger.new(logger2)
+        your_custom_observer1 = Observer::NullObserver.new
+        your_custom_observer2 = Observer::NullObserver.new
+
+        super(
+          migration,
+          stdout_logger_debug,
+          stdout_logger_info,
+          your_custom_observer1,
+          your_custom_observer2,
+        )
+
+        @messenger = messenger
+      end
+
+      private
+      attr_reader :messenger
+    end
+  end
+end

data/example/observer/progress_bar.rb

@@ -0,0 +1,26 @@
+require 'processor/observer/null_observer'
+require 'progressbar'
+
+module Processor
+  module Example
+    module Observer
+      class ProgressBar < Processor::Observer::NullObserver
+        def processing_started
+          @progress_bar = ::ProgressBar.new("Records", processor.total_records)
+          messenger.debug "Initialized ProgressBar with #{processor.total_records} records"
+        end
+
+        def before_record_processing(record)
+          progress_bar.inc
+        end
+
+        def processing_finished
+          progress_bar.finish
+        end
+
+        private
+        attr_reader :progress_bar
+      end
+    end
+  end
+end

data/example/solr_migration.rb

@@ -0,0 +1,31 @@
+require 'processor/data_processor'
+
+module Processor
+  module Example
+    class SolrMigration < DataProcessor
+      def process(user)
+        user.set_contact_method "Address book"
+        user.save!
+      end
+
+      def fetch_records
+        query.results
+      end
+
+      def total_records
+        @total_records ||= query.total
+      end
+
+      private
+      # query will return 0 records when all users'll be processed successfully
+      def query
+        User.search {
+          fulltext "My company"
+          with :title, "Manager"
+          with :contact_method, "Direct contact"
+          paginate page: 1, per_page: 10
+        }
+      end
+    end
+  end
+end

data/example/solr_pages_migration.rb

@@ -0,0 +1,48 @@
+require 'processor/data_processor'
+
+module Processor
+  module Example
+    class SolrPagesMigration < DataProcessor
+      def done?(records)
+        # Optional custom check for migration to be done.
+
+        # your custom check
+
+        # use a default check if you like
+        super
+      end
+
+      def process(user)
+        user.set_contact_method "Address book"
+        user.save!
+      end
+
+      def fetch_records
+        query(next_page).results
+      end
+
+      def total_records
+        @total_records ||= query(1).total
+      end
+
+      # optional name to use in observers.
+      def name
+        "my_company_users_contact_method_migration"
+      end
+
+      private
+      def query(requested_page)
+        User.search {
+          fulltext "My company"
+          paginate page: requested_page, per_page: 10
+        }
+      end
+
+      def next_page
+        @page ||= 0
+        @page += 1
+      end
+    end
+  end
+end
+

data/lib/processor/data_processor.rb

@@ -0,0 +1,28 @@
+module Processor
+  class DataProcessor
+    def done?(records)
+      records.count < 1
+    end
+
+    def process(record)
+      raise NotImplementedError
+    end
+
+    def fetch_records
+      raise NotImplementedError
+    end
+
+    def total_records
+      raise NotImplementedError
+    end
+
+    def name
+      # underscore a class name
+      self.class.name.to_s.
+        gsub(/::/, '_').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        downcase
+    end
+  end
+end

data/lib/processor/events_registrator.rb

@@ -0,0 +1,16 @@
+module Processor
+  class EventsRegistrator
+    def initialize(observers)
+      @observers = observers
+    end
+
+    def register(event, *data)
+      observers.each do |observer|
+        observer.update event, *data
+      end
+    end
+
+    private
+    attr_reader :observers
+  end
+end

data/lib/processor/observer/logger.rb

@@ -0,0 +1,86 @@
+require_relative 'null_observer'
+require 'logger'
+
+module Processor
+  module Observer
+    class Logger < NullObserver
+      def initialize(logger = nil, options = {})
+        @logger_source = logger
+        super options
+      end
+
+      def processing_started(processor)
+        initialize_logger(processor)
+        logger.info "Processing of #{processor.name} started."
+
+        message = <<-MESSAGE.gsub(/^\s+/, '')
+          Proggress will be saved to the log file. Run
+          tail -f #{log_file_name}
+          to see log in realtime
+          MESSAGE
+          messenger.info message if use_log_file?
+      end
+
+      def before_record_processing(record)
+        logger.debug "Record #{id_for record} is going to be processed"
+      end
+
+      def after_record_processing(record, result)
+        logger.info "Successfully processed #{id_for record}: #{result}"
+      end
+
+      def processing_finished(processor)
+        logger.info "Processing of #{processor.name} finished."
+        messenger.info "Log file saved to #{log_file_name}" if use_log_file?
+      end
+
+      def record_processing_error(record, exception)
+        logger.error "Error processing #{id_for record}: #{exception}"
+      end
+
+      def processing_error(processor, exception)
+        logger.fatal "Processing #{processor.name} failed: #{exception}"
+      end
+
+      private
+      attr_reader :logger, :log_file_name
+
+      def initialize_logger(processor)
+        @logger =
+          if @logger_source.is_a? Proc
+            @logger_source.call processor.name
+          else
+            @logger_source or ::Logger.new(create_log_filename(processor.name)).tap do |logger|
+              logger.level = ::Logger::INFO
+            end
+          end
+        messenger.debug "Observer initialized with logger #{@logger}"
+      end
+
+      def create_log_filename(processor_name)
+        @log_file_name = "log/#{processor_name}_on_#{current_time_string}.log"
+      end
+
+      def use_log_file?
+        not log_file_name.nil?
+      end
+
+      def current_time_string
+        Time.now.gmtime.strftime "%Y-%m-%d_%H%M%S_UTC"
+      end
+
+      def id_for record
+        [:uid, :id, :to_token, :token, :to_sym].each do |method|
+          return record.public_send method if record.respond_to? method
+        end
+
+        [:uid, :id, :token, :sym, :UID, :ID, :TOKEN, :SYM].each do |method|
+          return record[method] if record.key? method
+          return record[method.to_s] if record.key? method.to_s
+        end if record.respond_to?(:key?) && record.respond_to?(:[])
+
+        record.to_s
+      end
+    end
+  end
+end

data/lib/processor/observer/null_observer.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module Processor
+  module Observer
+    class NullObserver
+      def initialize(options = {})
+        @messenger = options.fetch :messenger do
+          ::Logger.new(STDOUT).tap do |logger|
+            logger.formatter =  -> _, _, _, msg do
+              "> #{msg}\n"
+            end
+            logger.level = ::Logger::INFO
+          end
+        end
+      end
+
+      def method_missing(*); end
+      alias_method :update, :send
+
+      private
+      attr_reader :messenger
+    end
+  end
+end

data/lib/processor/records_processor/successive.rb

@@ -0,0 +1,20 @@
+module Processor
+  module RecordsProcessor
+    class Successive
+      def call(records, processor, events, recursion_preventer)
+        records.each do |record|
+          recursion_preventer.call
+          begin
+            events.register :before_record_processing, record
+
+            result = processor.process(record)
+
+            events.register :after_record_processing, record, result
+          rescue RuntimeError => exception
+            events.register :record_processing_error, record, exception
+          end
+        end
+      end
+    end
+  end
+end

data/lib/processor/records_processor/threads.rb

@@ -0,0 +1,27 @@
+module Processor
+  module RecordsProcessor
+    class Threads
+      def call(records, processor, events, recursion_preventer)
+        threads = []
+        begin
+          records.each do |record|
+            recursion_preventer.call
+            threads << ::Thread.new(processor, record) do |thread_data_processor, thread_record|
+              begin
+                events.register :before_record_processing, thread_record
+
+                result = thread_data_processor.process(thread_record)
+
+                events.register :after_record_processing, thread_record, result
+              rescue RuntimeError => exception
+                events.register :record_processing_error, thread_record, exception
+              end
+            end
+          end
+        ensure # join already created threads even if recursion was detected
+          threads.each(&:join)
+        end
+      end
+    end
+  end
+end

data/lib/processor/runner.rb

@@ -0,0 +1,39 @@
+require_relative "events_registrator"
+
+module Processor
+  class Runner
+    def initialize(processor, events_registrator)
+      @processor = processor
+      @events = events_registrator
+    end
+
+    def run(records_processor)
+      events.register :processing_started, processor
+      until processor.done?(records = processor.fetch_records)
+        records_processor.call records, processor, events, method(:recursion_preventer)
+      end
+
+      events.register :processing_finished, processor
+    rescue Exception => exception
+      events.register :processing_error, processor, exception
+      raise exception
+    end
+
+    protected
+    attr_writer :counter
+    def counter
+      @counter ||= 0
+    end
+
+    private
+    attr_reader :events, :processor
+    def recursion_preventer
+      self.counter += 1
+      raise Exception, "Processing fall into recursion. Check logs." if self.counter > max_records_to_process
+    end
+
+    def max_records_to_process
+      (processor.total_records * 1.1).round + 10
+    end
+  end
+end

data/lib/processor/thread.rb

@@ -0,0 +1,26 @@
+require 'processor/runner'
+require 'processor/records_processor/successive'
+require 'processor/records_processor/threads'
+
+module Processor
+  class Thread
+    def initialize(data_processor, *observers)
+      @runner = Runner.new data_processor, EventsRegistrator.new(observers)
+    end
+
+    def run_as(&records_processor)
+      runner.run records_processor
+    end
+
+    def run_successive
+      runner.run RecordsProcessor::Successive.new
+    end
+
+    def run_in_threads
+      runner.run RecordsProcessor::Threads.new
+    end
+
+    private
+    attr_reader :runner
+  end
+end

data/lib/processor/version.rb

@@ -1,3 +1,3 @@
 module Processor
-  VERSION = "0.0.0.initial"
+  VERSION = "0.0.1"
 end

data/spec/example_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper_lite'
+require_relative '../example/migrator'
+require_relative '../example/migration'
+
+describe "Example" do
+  before(:each) do
+    records = %w[item1 item2 item3 item4 item5]
+    records.each do |record|
+      record.should_receive(:do_something).once
+    end
+    @migration = Processor::Example::Migration.new records
+  end
+
+  it "migration should use 2 loggers and messenger" do
+    migrator = Processor::Example::Migrator.new @migration
+    migrator.migrate
+  end
+end

data/spec/processor/data_processor_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper_lite'
+require 'processor/data_processor'
+
+describe Processor::DataProcessor do
+  it "should have a name equals to underscored class name" do
+    subject.name.should eq "processor_data_processor"
+  end
+
+  it "should be done when there are 0 records to process" do
+    records = []
+    subject.done?(records).should be true
+  end
+
+  %w[done? fetch_records total_records process].each do |method_name|
+    it "should respond to #{method_name}" do
+      subject.should respond_to method_name
+    end
+  end
+end
+

data/spec/processor/events_registrator_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper_lite'
+require 'processor/events_registrator'
+
+describe Processor::EventsRegistrator do
+  subject { Processor::EventsRegistrator }
+
+  it "should broadcast events to all observers" do
+    observers = 3.times.map do
+      stub(:observer).tap { |observer| observer.should_receive(:update).with(:test_event).once }
+    end
+
+    events = subject.new(observers)
+    events.register :test_event
+  end
+end

data/spec/processor/observer/logger_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper_lite'
+require 'processor/observer/logger'
+
+describe Processor::Observer::Logger do
+  let(:processor) { stub.as_null_object }
+  let(:no_messages) { ::Logger.new("/dev/null") }
+
+  subject { Processor::Observer::Logger }
+    it "accepts logger builder as parameter" do
+      external_logger = mock
+      logger_observer = subject.new -> name { external_logger }, messenger: no_messages
+
+      external_logger.should_receive(:info)
+      logger_observer.processing_started processor
+    end
+
+    it "accepts logger as parameter" do
+      external_logger = mock
+      logger_observer = subject.new external_logger, messenger: no_messages
+
+      external_logger.should_receive(:info)
+      logger_observer.processing_started processor
+    end
+
+    it "use ruby Logger if no external logger provided" do
+      logger_observer = subject.new nil, messenger: no_messages
+
+      Logger.should_receive(:new).and_return(stub.as_null_object)
+      logger_observer.processing_started processor
+    end
+end
+

data/spec/processor/records_processor/specs.rb

@@ -0,0 +1,38 @@
+shared_examples_for "a records processor" do
+  let(:records_processor) { described_class.new }
+  let(:records) { 1..2 }
+  let(:processor) { stub }
+
+  let(:no_recursion_preventer) { Proc.new{} }
+  let(:no_events) { stub.as_null_object }
+
+  it "should send each found record to processor" do
+    records.each { |record| processor.should_receive(:process).with(record) }
+    records_processor.call records, processor, no_events, no_recursion_preventer
+  end
+
+  describe "exception handling" do
+    describe "processing a record raised RuntimeError" do
+      it "should continue processing" do
+        processor.should_receive(:process).twice.and_raise(RuntimeError)
+        expect { records_processor.call records, processor, no_events, no_recursion_preventer }.to_not raise_error
+      end
+
+      it "should register a record_processing_error event" do
+        event = mock.tap { |event| event.should_receive(:trigger).any_number_of_times }
+
+        events_registrator = stub
+        events_registrator.should_receive(:register) do |event_name, failed_record, exception|
+          next if event_name != :record_processing_error
+          event_name.should eq :record_processing_error
+          exception.should be_a RuntimeError
+          event.trigger
+        end.any_number_of_times
+
+        processor.stub(:process).and_raise(RuntimeError)
+
+        records_processor.call records, processor, events_registrator, no_recursion_preventer rescue nil
+      end
+    end
+  end
+end

data/spec/processor/records_processor/successive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper_lite'
+require_relative 'specs'
+require 'processor/records_processor/successive'
+
+describe Processor::RecordsProcessor::Successive do
+  it_behaves_like "a records processor"
+end

data/spec/processor/records_processor/threads_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper_lite'
+require_relative 'specs'
+require 'processor/records_processor/threads'
+
+describe Processor::RecordsProcessor::Threads do
+  it_behaves_like "a records processor"
+  it "should run in defined number of threads"
+end

data/spec/processor/runner_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper_lite'
+require 'processor/runner'
+
+describe Processor::Runner do
+  let(:runner) { Processor::Runner.new(processor, events_registrator) }
+  let(:processor) { stub }
+  let(:events_registrator) { stub.as_null_object }
+  let(:no_records_processor) { Proc.new{} }
+
+  it "should fetch records from processor till it'll be done" do
+    processor.stub(:done?).and_return(false, false, true)
+    processor.should_receive(:fetch_records).exactly(3).times.and_return([])
+    runner.run no_records_processor
+  end
+
+  describe "exception handling" do
+    let(:record) { stub }
+    before(:each) do
+      processor.stub(:fetch_records).and_return([record], [record], [])
+    end
+
+    describe "processing records raised" do
+      before(:each) do
+        processor.stub(done?: false)
+      end
+
+      it "should break processing and rerise" do
+        expect do
+          runner.run Proc.new { raise RuntimeError }
+        end.to raise_error(RuntimeError)
+      end
+
+      it "should register a processing_error event" do
+        register_processing_error_event mock.tap { |event| event.should_receive :trigger }
+        runner.run Proc.new { raise RuntimeError } rescue nil
+      end
+    end
+
+    describe "fetching records raised" do
+      it "should break processing and rerise Exception" do
+        processor.stub(:fetch_records).and_raise(RuntimeError)
+        processor.should_not_receive(:process)
+        expect { runner.run no_records_processor }.to raise_error(RuntimeError)
+      end
+
+      it "should register a processing_error" do
+        register_processing_error_event mock.tap { |event| event.should_receive :trigger }
+
+        processor.stub(:fetch_records).and_raise(RuntimeError)
+        runner.run no_records_processor rescue nil
+      end
+    end
+
+    private
+    def register_processing_error_event(event)
+      # Check that processing_error event was register
+      events_registrator.should_receive(:register) do |event_name, current_processor, exception|
+        next if event_name != :processing_error
+        event_name.should eq :processing_error
+        current_processor.should eq processor
+        exception.should be_a RuntimeError
+        event.trigger
+      end.any_number_of_times
+    end
+  end
+
+  describe "recursion" do
+    before(:each) do
+      processor.stub(done?: false)
+      processor.stub(total_records: 100)
+      processor.stub(fetch_records: 1..3)
+    end
+
+    it "should not fall into recursion" do
+      processor.should_receive(:process).at_most(1000).times
+
+      expect do
+        records_processor = Proc.new do |records, records_processor, events, recursion_preventer|
+          records.each do |record|
+            recursion_preventer.call
+            records_processor.process record
+          end
+        end
+        runner.run records_processor
+      end.to raise_error(Exception, /Processing fall into recursion/)
+    end
+
+    it "should have 10% + 10 rerurns window" do
+      processor.should_receive(:process).exactly(120).times
+
+      expect do
+        records_processor = Proc.new do |records, records_processor, events, recursion_preventer|
+          records.each do |record|
+            recursion_preventer.call
+            processor.process record
+          end
+        end
+        runner.run records_processor
+      end.to raise_error(Exception, /Processing fall into recursion/)
+    end
+  end
+end
+

data/spec/processor/thread_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper_lite'
+require 'processor/thread'
+require_relative '../../example/migration'
+
+describe Processor::Thread do
+  before(:each) do
+    records = %w[item1 item2 item3 item4 item5]
+    records.each do |record|
+      record.should_receive(:do_something).once
+    end
+    @migration = Processor::Example::Migration.new records
+  end
+
+  it "should run a migration using provided block" do
+    thread = Processor::Thread.new @migration
+    thread.run_as do |records, processor, *|
+      records.each do |record|
+        processor.process record
+      end
+    end
+  end
+
+  it "should run a migration successive" do
+    thread = Processor::Thread.new @migration
+    thread.run_successive
+  end
+
+  it "should run a migration in threads" do
+    thread = Processor::Thread.new @migration
+    thread.run_in_threads
+  end
+
+  pending "should run a migration in specifien number of threads" do
+    thread = Processor::Thread.new @migration
+    thread.run_in_threads 3
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: processor
 version: !ruby/object:Gem::Version
-  version: 0.0.0.initial
-  prerelease: 6
+  version: 0.0.1
+  prerelease: 
 platform: ruby
 authors:
 - Alexander Paramonov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-30 00:00:00.000000000 Z
+date: 2013-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -67,15 +67,39 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - .rvmrc
 - .travis.yml
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- example/logging_thread.rb
+- example/migration.rb
+- example/migrator.rb
+- example/observer/progress_bar.rb
+- example/solr_migration.rb
+- example/solr_pages_migration.rb
 - lib/processor.rb
+- lib/processor/data_processor.rb
+- lib/processor/events_registrator.rb
+- lib/processor/observer/logger.rb
+- lib/processor/observer/null_observer.rb
+- lib/processor/records_processor/successive.rb
+- lib/processor/records_processor/threads.rb
+- lib/processor/runner.rb
+- lib/processor/thread.rb
 - lib/processor/version.rb
 - processor.gemspec
+- spec/example_spec.rb
+- spec/processor/data_processor_spec.rb
+- spec/processor/events_registrator_spec.rb
+- spec/processor/observer/logger_spec.rb
+- spec/processor/records_processor/specs.rb
+- spec/processor/records_processor/successive_spec.rb
+- spec/processor/records_processor/threads_spec.rb
+- spec/processor/runner_spec.rb
+- spec/processor/thread_spec.rb
 - spec/spec_helper_lite.rb
 homepage: http://github.com/AlexParamonov/processor
 licenses:
@@ -90,12 +114,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 4470760754938067473
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
+      segments:
+      - 0
+      hash: 4470760754938067473
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -103,4 +133,13 @@ signing_key:
 specification_version: 3
 summary: Process records one by one
 test_files:
+- spec/example_spec.rb
+- spec/processor/data_processor_spec.rb
+- spec/processor/events_registrator_spec.rb
+- spec/processor/observer/logger_spec.rb
+- spec/processor/records_processor/specs.rb
+- spec/processor/records_processor/successive_spec.rb
+- spec/processor/records_processor/threads_spec.rb
+- spec/processor/runner_spec.rb
+- spec/processor/thread_spec.rb
 - spec/spec_helper_lite.rb