sidekiq-superworker 0.1.4 → 0.1.5

data/app/models/sidekiq/superworker/subjob.rb

@@ -3,7 +3,7 @@ module Sidekiq
     class Subjob < ActiveRecord::Base
       attr_accessible :jid, :subjob_id, :superjob_id, :parent_id, :children_ids, :next_id,
         :subworker_class, :superworker_class, :arg_keys, :arg_values, :status, :descendants_are_complete,
-        :meta if ActiveRecord::VERSION::MAJOR < 4
+        :meta if ActiveRecord::VERSION::MAJOR < 4 || ActiveRecord.constants.include?(:MassAssignmentSecurity)
 
       serialize :arg_keys
       serialize :arg_values

data/lib/sidekiq/superworker/dsl_hash.rb

@@ -1,33 +1,27 @@
 module Sidekiq
   module Superworker
     class DSLHash
-      attr_accessor :record_id, :records
+      attr_accessor :record_id
 
-      def initialize
-        reset
-      end
-
-      def nested_hash_to_records(nested_hash, args)
-        reset
+      def initialize(hash, args={})
+        @hash = hash
         @args = args
-        nested_hash_to_records_recursive(nested_hash)
       end
 
-      def rewrite_ids_of_nested_hash(nested_hash, record_id)
-        reset
-        @record_id = record_id
-        rewrite_ids_of_nested_hash_recursive(nested_hash)
+      def rewrite_record_ids(first_record_id)
+        @record_id = first_record_id - 1
+        rewrite_ids_of_nested_hash(@hash)
       end
 
-      private
-
-      def reset
-        @args = {}
-        @records = {}
+      def to_records
         @record_id = 1
+        @records = {}
+        nested_hash_to_records(@hash)
       end
 
-      def nested_hash_to_records_recursive(nested_hash, options={})
+      private
+
+      def nested_hash_to_records(nested_hash, options={})
         return @records if nested_hash.blank?
 
         defaults = {
@@ -70,24 +64,11 @@ module Sidekiq
             @records[parent_id][:children_ids] << id
           end
 
-          nested_hash_to_records_recursive(value[:children], parent_id: id, scoped_args: options[:scoped_args]) if value[:children] && value[:subworker_class] != :batch
+          nested_hash_to_records(value[:children], parent_id: id, scoped_args: options[:scoped_args]) if value[:children] && value[:subworker_class] != :batch
         end
         @records
       end
 
-      def rewrite_ids_of_nested_hash_recursive(nested_hash)
-        new_hash = {}
-        nested_hash.each do |old_record_id, record|
-          @record_id += 1
-          parent_record_id = @record_id
-          new_hash[parent_record_id] = record
-          if record[:children]
-            new_hash[parent_record_id][:children] = rewrite_ids_of_nested_hash_recursive(record[:children])
-          end
-        end
-        new_hash
-      end
-
       def children_ids_for_batch(subjobs, batch_keys_to_iteration_keys)
         iteration_keys = batch_keys_to_iteration_keys.values
         batch_iteration_arg_value_arrays = get_batch_iteration_arg_value_arrays(batch_keys_to_iteration_keys)
@@ -125,7 +106,7 @@ module Sidekiq
             @records[subjob_id] = subjob
             @records[last_subjob_id][:next_id] = subjob_id if last_subjob_id
             last_subjob_id = subjob_id
-            nested_hash_to_records_recursive(children, parent_id: subjob_id, scoped_args: iteration_args)
+            nested_hash_to_records(children, parent_id: subjob_id, scoped_args: iteration_args)
           end
 
           children_ids << batch_child_id
@@ -145,6 +126,19 @@ module Sidekiq
         batch_values = first_batch_value.zip(*batch_values)
         batch_values
       end
+
+      def rewrite_ids_of_nested_hash(nested_hash)
+        new_hash = {}
+        nested_hash.each do |old_record_id, record|
+          @record_id += 1
+          parent_record_id = @record_id
+          new_hash[parent_record_id] = record
+          if record[:children]
+            new_hash[parent_record_id][:children] = rewrite_ids_of_nested_hash(record[:children])
+          end
+        end
+        new_hash
+      end
     end
   end
 end

data/lib/sidekiq/superworker/dsl_parser.rb

@@ -1,49 +1,51 @@
 module Sidekiq
   module Superworker
     class DSLParser
-      def self.parse(block)
+      MODULE_SEPARATOR = '__'
+
+      def parse(block)
         @dsl_evaluator = DSLEvaluator.new
-        @dsl_hash = DSLHash.new
         @record_id = 0
         nested_hash = block_to_nested_hash(block)
-        @dsl_hash.rewrite_ids_of_nested_hash(nested_hash, 0)
+        DSLHash.new(nested_hash).rewrite_record_ids(1)
       end
 
-      def self.block_to_nested_hash(block)
+      def block_to_nested_hash(block)
         fiber = Fiber.new do
           @dsl_evaluator.instance_eval(&block)
         end
         
         nested_hash = {}
         while (method_result = fiber.resume)
-          method, args, block = method_result
-          @record_id += 1
-          method_record_id = @record_id
-          if block
-            if method == :batch
-              nested_hash[@record_id] = { subworker_class: method, arg_keys: args, children: block_to_nested_hash(block) }
-            else
-              nested_hash[@record_id] = { subworker_class: method, arg_keys: args, children: block_to_nested_hash(block) }
-            end
-          else
-            nested_hash[@record_id] = { subworker_class: method, arg_keys: args }
-          end
+          add_method_result_to_nested_hash(nested_hash, method_result)
+        end
+        nested_hash
+      end
 
-          # For superworkers nested within other superworkers, we'll take the subworkers' nested_hash,
-          # adjust their ids to fit in with our current @record_id value, and add them into the tree.
-          unless [:parallel, :batch].include?(method)
-            subworker_class = method.to_s.constantize
-            if subworker_class.respond_to?(:is_a_superworker?) && subworker_class.is_a_superworker?
-              children = @dsl_hash.rewrite_ids_of_nested_hash(subworker_class.nested_hash, @record_id)
-              set_children_for_record_id(nested_hash, method_record_id, children)
-              @record_id = @dsl_hash.record_id
-            end
+      def add_method_result_to_nested_hash(nested_hash, method_result)
+        method, args, block = method_result
+        subworker_type = method_to_subworker_type(method)
+        @record_id += 1
+        method_record_id = @record_id
+
+        record = { subworker_class: subworker_type, arg_keys: args }
+        record[:children] = block_to_nested_hash(block) if block
+        nested_hash[method_record_id] = record
+
+        # For superworkers nested within other superworkers, we'll take the subworkers' nested_hash,
+        # adjust their ids to fit in with our current @record_id value, and add them into the tree.
+        unless [:parallel, :batch].include?(subworker_type)
+          subworker_class = subworker_type.to_s.constantize
+          if subworker_class.respond_to?(:is_a_superworker?) && subworker_class.is_a_superworker?
+            dsl_hash = DSLHash.new(subworker_class.nested_hash)
+            children = dsl_hash.rewrite_record_ids(@record_id + 1)
+            set_children_for_record_id(nested_hash, method_record_id, children)
+            @record_id = dsl_hash.record_id
           end
         end
-        nested_hash
       end
 
-      def self.set_children_for_record_id(nested_hash, parent_record_id, children)
+      def set_children_for_record_id(nested_hash, parent_record_id, children)
         nested_hash.each do |record_id, value|
           if record_id == parent_record_id
             if nested_hash[record_id][:children].present?
@@ -57,6 +59,27 @@ module Sidekiq
           end
         end
       end
+
+      def method_to_subworker_type(method)
+        method = method.to_s
+        if method.include?(MODULE_SEPARATOR)
+          method_pieces = method.split(MODULE_SEPARATOR)
+          class_name = method_pieces.pop
+          module_name = method_pieces.join('::')
+        else
+          module_name = nil
+          class_name = method
+        end
+
+        return class_name.to_sym if module_name.nil?
+
+        begin
+          namespaced_class = [module_name, class_name].compact.join('::').constantize
+        rescue NameError
+          namespaced_class = [module_name, class_name].compact.join(MODULE_SEPARATOR).constantize
+        end
+        namespaced_class.to_s
+      end
     end
   end
 end

data/lib/sidekiq/superworker/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module Superworker
-    VERSION = '0.1.4'
+    VERSION = '0.1.5'
   end
 end

data/lib/sidekiq/superworker/worker.rb

@@ -3,7 +3,7 @@ module Sidekiq
     class Worker
       def self.create(*args, &block)
         class_name = args.shift.to_sym
-        nested_hash = DSLParser.parse(block)
+        nested_hash = DSLParser.new.parse(block)
         create_class(class_name, args, nested_hash)
       end
 
@@ -14,10 +14,17 @@ module Sidekiq
           @class_name = class_name
           @arg_keys = arg_keys
           @nested_hash = nested_hash
-          @dsl_hash = DSLHash.new
         end
 
-        Object.const_set(class_name, klass)
+        class_components = class_name.to_s.split('::')
+        class_name = class_components.pop
+        module_name = class_components.join('::')
+
+        if module_name.empty?
+          Object.const_set(class_name, klass)
+        else
+          module_name.constantize.const_set(class_name, klass)
+        end
       end
     end
   end

data/lib/sidekiq/superworker/worker_class.rb

@@ -33,7 +33,7 @@ module Sidekiq
         end
 
         def create_subjobs(arg_values, options={})
-          records = @dsl_hash.nested_hash_to_records(@nested_hash, @args)
+          records = DSLHash.new(@nested_hash, @args).to_records
           records = records.collect do |id, record|
             record[:status] = 'initialized'
             record[:superjob_id] = @superjob_id

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-superworker
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-10 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq