ultra_marathon 0.1.7 → 0.1.10

data/lib/ultra_marathon/logging.rb

@@ -20,7 +20,7 @@ module UltraMarathon
       # is set to be the instance variable. Otherwise returns it, defaulting
       # to the included Logger class
       def logger_class
-        if @logger_class && @logger_class.respond_to?(:call)
+        if @logger_class.respond_to? :call
           @logger_class = @logger_class.call
         else
           @logger_class ||= Logger

data/lib/ultra_marathon/store.rb

@@ -21,6 +21,10 @@ module UltraMarathon
     end
     alias_method :add, :<<
 
+    def merge(other_store)
+      self.store.merge!(other_store.store)
+    end
+
     def each(&block)
       runners.each(&block)
     end
@@ -64,6 +68,15 @@ module UltraMarathon
       end
     end
 
+    protected
+
+    ## Protected Instance Methods
+
+    # allow access for another store for merging
+    def store
+      @store ||= Hash.new
+    end
+
     private
 
     ## Private Instance Methods
@@ -71,9 +84,5 @@ module UltraMarathon
     def runners
       store.values
     end
-
-    def store
-      @store ||= Hash.new
-    end
   end
 end

data/lib/ultra_marathon/sub_context.rb

@@ -0,0 +1,36 @@
+module UltraMarathon
+  class SubContext
+    include Logging
+    attr_reader :__context
+
+    # Initializes the SubContext and defines #call as the passed in run_block
+    # @param context [Object] the context in which to run the run_block. Any
+    #   logging calls will be intercepted to allow threaded execution.
+    # @param run_block [Proc] the block to be run in the given context
+    # @return [self] the initialized SubContext
+    def initialize(context, &run_block)
+      @__context = context
+      # Ruby cannot marshal procs or lambdas, so we need to define a method.
+      # Binding to self allows us to intercept logging calls.
+      define_singleton_method(:call, run_block.bind(self))
+    end
+
+    # If the original context responds, including private methods,
+    # delegate to it
+    #
+    # @param method [Symbol] the method called. If context responds to this
+    #   method, it will be called on the context
+    # @param args [Array] the arguments the method was called with
+    # @param block [Proc] proc called with method, if applicable
+    # @raise [NoMethodError] if the context, including private methods, does not
+    #   respond to the method called
+    def method_missing(method, *args, &block)
+
+      if __context.respond_to?(method, true)
+        __context.send(method, *args, &block)
+      else
+        raise NoMethodError.new("undefined local variable or method `#{method.to_s}' for #{__context.class.name}")
+      end
+    end
+  end
+end

data/lib/ultra_marathon/sub_runner.rb

@@ -3,108 +3,164 @@ require 'core_ext/proc'
 require 'ultra_marathon/callbacks'
 require 'ultra_marathon/instrumentation'
 require 'ultra_marathon/logging'
+require 'ultra_marathon/sub_context'
 
 module UltraMarathon
   class SubRunner
     include Callbacks
     include Instrumentation
     include Logging
-    attr_accessor :run_block, :success
-    attr_reader :sub_context, :options, :name
+    attr_accessor :success, :run_thread
+    attr_reader :options, :name, :run_block_or_sub_context
 
     callbacks :before_run, :after_run, :on_error, :on_reset
-    after_run :log_header_and_sub_context
+
+    before_run lambda { logger.info "Running '#{name}' SubRunner" }
+    after_run lambda { logger.info sub_context.logger.contents }
+    on_reset lambda { self.run_thread = nil }
 
     on_error lambda { self.success = false }
-    on_error lambda { |error| logger.error error }
+    on_error lambda { |error| logger.error(error) }
+
+    instrumentation_prefix lambda { |sub_runner| "sub_runner.#{sub_runner.name}." }
 
     # The :context option is required, because you'll never want to run a
     # SubRunner in context of itself.
     # SubContext is necessary because we want to run in the context of the
     # other class, but do other things (like log) in the context of this one.
-    def initialize(options, run_block)
-      @name = options[:name]
+    #
+    #
+    # @param options [Hash] the options for instantiation
+    # @option options [String] :name The name of the sub runner
+    # @option options [Object] :context The context in which the run block will
+    #   be run. Only required if second parameter is a callable object and not
+    #   a SubContext already.
+    # @option options [Boolean] :instrument (false) whether to log
+    #   instrumentation information.
+    # @option options [Boolean] :threaded (false) whether to run in a separate
+    #   thread.
+    # @option options [Array, Set] :requires ([]) the names of sub runners that
+    #   should have successfully run before this one. Not used by this class
+    #   but necessary state for enveloping runners.
+    # @param run_block_or_sub_context [Proc, SubContext] either a proc to be run
+    #   within a new SubContext
+    def initialize(options, run_block_or_sub_context)
+      @run_block_or_sub_context = run_block_or_sub_context
+      @name = options.delete(:name)
       @options = {
-        instrument: false
+        instrument: false,
+        threaded: false,
+        requires: Set.new,
+        timeout: 100
       }.merge(options)
-      @sub_context = SubContext.new(options[:context], run_block)
     end
 
+    # Run the run block or sub context. If {#threaded?} is true, will
+    # envelope the run in a thread and immediately return. If there is already
+    # an active thread, it will not run again.
+    # @return [self]
     def run!
-      instrument(:run) do
-        begin
-          self.success = true
-          run_sub_context
-        rescue StandardError => error
-          invoke_on_error_callbacks(error)
-        ensure
-          invoke_after_run_callbacks
-        end
+      if threaded?
+        run_in_thread
+      else
+        run_without_thread
       end
-      log_instrumentation
+      self
     end
 
-    def log_instrumentation
-      if options[:instrument]
-        run_profile = instrumentations[:run]
-        logger.info """
-        End Time: #{run_profile.formatted_end_time}
-        Start Time: #{run_profile.formatted_start_time}
-        Total Time: #{run_profile.formatted_total_time}
-        """
+    # Tells whether the runner has completed. If running in a threaded context,
+    # checks if the thread is alive. Otherwise, returns true.
+    # @return [Boolean] whether the runner has compeleted running
+    def complete?
+      if threaded?
+        !running?
+      else
+        true
+      end
+    end
+
+    # If {#threaded?}, returns if the run_thread is alive. Otherwise false.
+    # @return [Boolean] whether the SubRunner is currently executing {#run!}
+    def running?
+      if threaded?
+        run_thread && run_thread.alive?
+      else
+        false
       end
     end
 
+    # @return [Boolean] whether {#run!} will be executed in a thread.
+    def threaded?
+      !!options[:threaded]
+    end
+
+    # Invokes all on_reset callbacks
+    # @return [self]
     def reset
       invoke_on_reset_callbacks
+      self
     end
 
-    # Set of all sub runners that should be run before this one.
-    # This class cannot do anything with this information, but it is useful
-    # to the enveloping runner.
+    # Set of all sub runners that should be run before this one, as specified
+    # by the :requires option.
+    # @return [Set] set of all runner names that should be run before this one.
     def parents
       @parents ||= Set.new(options[:requires])
     end
 
     private
 
-    def run_sub_context
-      invoke_before_run_callbacks
-      sub_context.call
-    end
-
-    def log_header_and_sub_context
-      logger.info log_header
-      log_sub_context
-    end
-
-    def log_sub_context
-      logger.info sub_context.logger.contents
+    # Wraps {#run_without_thread} in a Thread unless {#running?} returns true.
+    # @return [Thread, nil]
+    def run_in_thread
+      unless running?
+        self.run_thread = Thread.new { run_without_thread }
+      end
     end
 
-    def log_header
-      "Running '#{name}' SubRunner"
+    # Runs the before_run callbacks, then calls sub_context
+    # If an error is raised in the sub_context, it invokes the on_error
+    # callbacks passing in that error
+    # Finally, runs the after_run callbacks whether or not an error was raised
+    # @return [self]
+    def run_without_thread
+      instrument('__run!') do
+        begin
+          self.success = true
+          instrument('callbacks.before_run') { invoke_before_run_callbacks }
+          sub_context.call
+        rescue StandardError => error
+          instrument('callbacks.on_error') { invoke_on_error_callbacks(error) }
+        ensure
+          instrument('callbacks.after_run') { invoke_after_run_callbacks }
+        end
+      end
+      log_instrumentation if options[:instrument]
+      self
     end
-  end
-
-  class SubContext
-    include Logging
-    attr_reader :context, :run_block
 
-    def initialize(context, run_block)
-      @context = context
-      # Ruby cannot marshal procs or lambdas, so we need to define a method.
-      # Binding to self allows us to intercept logging calls.
-      define_singleton_method(:call, &run_block.bind(self))
+    # Logs the start time, end time, and total time for {#run!}
+    # @return [void]
+    def log_instrumentation
+      run_profile = instrumentations['__run!']
+      logger.info """
+      Start Time: #{run_profile.formatted_start_time}
+      End Time: #{run_profile.formatted_end_time}
+      Total Time: #{run_profile.formatted_total_time}
+      """
     end
 
-    # If the original context responds, including private methods,
-    # delegate to it
-    def method_missing(method, *args, &block)
-      if context.respond_to?(method, true)
-        context.send(method, *args, &block)
-      else
-        raise NoMethodError.new("undefined local variable or method `#{method.to_s}' for #{context.class.name}")
+    # Returns the sub context to be called by {#run!}. If initialized with an
+    # instance on SubContext, memoizes to that. Otherwise, creates a new
+    # SubContext with the passed in context and run block
+    # @return [SubContext]
+    def sub_context
+      @sub_context ||= begin
+        if run_block_or_sub_context.is_a? SubContext
+          run_block_or_sub_context
+        else
+          SubContext.new(options[:context], &run_block_or_sub_context)
+        end
       end
     end
   end

data/lib/ultra_marathon/version.rb

@@ -2,7 +2,7 @@ module UltraMarathon
   class Version
     MAJOR = 0 unless defined? MAJOR
     MINOR = 1 unless defined? MINOR
-    PATCH = 7 unless defined? PATCH
+    PATCH = 10 unless defined? PATCH
     PRE = nil unless defined? PRE
 
     class << self

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'fileutils'
 require 'awesome_print'
 require 'timecop'
 require 'ultra_marathon'
@@ -6,3 +7,13 @@ require 'rspec/autorun'
 require 'support/test_helpers'
 
 include TestHelpers
+
+# TODO Google this when I have Wifi
+# TEST_TMP_DIRECTORY = 'test_tmp'.freeze
+
+# before(:suite) do
+#   Dir.mkdir_p(TEST_TMP_DIRECTORY)
+#   Dir.foreach(TEST_TMP_DIRECTORY) do |file_name|
+#     File.delete(file_name)
+#   end
+# end

data/spec/ultra_marathon/abstract_runner_spec.rb

@@ -5,10 +5,11 @@ describe UltraMarathon::AbstractRunner do
   let(:test_instance) { test_class.new }
 
   describe '#run!' do
+    let(:run_options) { Hash.new }
     subject { test_instance.run! }
 
     describe 'with one run block' do
-      before(:each) { test_class.send :run, &run_block }
+      before(:each) { test_class.send :run, :main, run_options, &run_block }
 
       context 'when everything is fine' do
         let(:run_block) { Proc.new { logger.info 'Look at me go!' } }
@@ -52,6 +53,35 @@ describe UltraMarathon::AbstractRunner do
       end
     end
 
+    context 'with a collection' do
+      let(:items) { [1,2,3,4] }
+      let(:run_block) do
+        Proc.new do |n|
+          squares << (n ** 2)
+        end
+      end
+      let(:test_class) do
+        anonymous_test_class(UltraMarathon::AbstractRunner) do
+          def squares
+            @squares ||= []
+          end
+        end
+      end
+
+      before(:each) { test_instance.class.send :run_collection, :main, items, run_options, &run_block }
+
+      it 'should run successfully' do
+        subject
+        test_instance.should be_success
+      end
+
+      it 'should execute the run blocks in the context of the test class' do
+        subject
+        test_instance.squares.sort.should eq [1,4,9,16]
+      end
+
+    end
+
     describe 'with multiple run blocks' do
 
       context 'when everything is fine' do
@@ -119,10 +149,12 @@ describe UltraMarathon::AbstractRunner do
           end
         end
       end
+
     end
   end
 
   describe 'callbacks' do
+    let(:run_block) { Proc.new { 7 } }
     before(:each) { test_class.send :run, &run_block }
 
     subject { test_instance.run! }
@@ -154,6 +186,17 @@ describe UltraMarathon::AbstractRunner do
         test_instance.logger.contents.index('We have liftoff!').should be > test_instance.logger.contents.index('Blastoff!')
       end
     end
+
+    describe 'after_initialize callback' do
+      before(:each) do
+        test_class.after_initialize ->{ self.success = 'Pebbles' }
+        test_class.after_initialize ->{ self.success << ' in my shower' }
+      end
+
+      it 'should invoke after_initialize callbacks in order' do
+        test_instance.success.should eq 'Pebbles in my shower'
+      end
+    end
   end
 
   describe '#reset' do

data/spec/ultra_marathon/collection_runner_spec.rb

@@ -0,0 +1,96 @@
+require 'timeout'
+require 'spec_helper'
+
+describe UltraMarathon::CollectionRunner do
+  let(:test_class) { anonymous_test_class(UltraMarathon::CollectionRunner) }
+  let(:test_instance) { test_class.new(collection, options, &run_block) }
+  let(:collection) { [] }
+  let(:options) { { name: :justice_league } }
+  let(:run_block) { Proc.new { } }
+
+  describe '#run!' do
+    subject(:run_collection) { test_instance.run! }
+    context 'with a single elements' do
+      let(:collection) { [1, 3, 5, 7, 9] }
+      let(:run_block) do
+        proc { |item| logger.info("Chillin with homie #{item}")}
+      end
+
+      it 'should run each member of the collection' do
+        run_collection
+        collection.each do |item|
+          sub_log = "Chillin with homie #{item}\n"
+          test_instance.logger.contents.should include sub_log
+        end
+      end
+
+      context 'when individual elements blow up' do
+        let(:collection) { [1,2,3,4,5] }
+
+        let(:run_block) do
+          proc { |item| raise 'hell' if item % 2 == 0 }
+        end
+
+        it 'should not raise an error and set success to false' do
+          expect { run_collection }.to_not raise_error
+          test_instance.success.should be false
+          test_instance.failed_sub_runners.length.should be 2
+          test_instance.successful_sub_runners.length.should be 3
+        end
+      end
+    end
+
+    context 'with multiple arguments' do
+      let(:collection) { [['Cassidy', 'Clay'], ['Tom', 'Jerry']] }
+      let(:run_block) do
+        proc { |homie1, homie2| logger.info("Chillin with homie #{homie1} & #{homie2}") }
+      end
+
+      it 'should run each member of the collection' do
+        run_collection
+        collection.each do |(homie1, homie2)|
+          sub_log = "Chillin with homie #{homie1} & #{homie2}\n"
+          test_instance.logger.contents.should include sub_log
+        end
+      end
+    end
+
+    context 'with a different iterator' do
+      let(:number_array_class) do
+        anonymous_test_class(Array) do
+          def each_odd(&block)
+            select(&:odd?).each(&block)
+          end
+        end
+      end
+      let(:collection) { number_array_class.new([1,2,3,4,5,6]) }
+      let(:run_block) { proc { |odd_number| logger.info "#{odd_number} is an odd number!" } }
+      let(:options) { { name: :this_is_odd, iterator: :each_odd } }
+
+      it 'should use that iterator' do
+        run_collection
+        test_instance.logger.contents.should_not include "2 is an odd number!"
+      end
+    end
+
+    context 'with a custom naming convention' do
+      let(:options) { { name: :jimmy, sub_name: proc { |index, item| 'Sector' << (item ** 2).to_s } } }
+      let(:collection) { [ 2, 4, 7] }
+
+      it 'should correctly set the sub_runner names as requested' do
+        run_collection
+        test_instance.logger.contents.should include "Running 'Sector49' SubRunner"
+      end
+    end
+
+    context 'passing threaded: true' do
+      let(:options) { { name: :threaded, threaded: true } }
+      let(:collection) { 0...10 }
+      let(:run_block) { proc { |n| sleep(0.01) } }
+
+      it 'should generate threaded subrunners' do
+        test_instance.send(:unrun_sub_runners).all?(&:threaded?).should be true
+      end
+    end
+  end
+end