burstflow 0.2.0 → 0.2.1

data/lib/burstflow/workflow/builder.rb

@@ -1,91 +1,94 @@
 module Burstflow
-  
-class Workflow::Builder
-  def initialize workflow, *args, &block
-    @workflow = workflow
-    @deps = []
-    @jobs_by_class = {}
-    @jobs_by_id = {}
-
-    @workflow.jobs_config.each_pair do |id, job_hash|
-      job = Burstflow::Job.from_hash(@workflow, job_hash)
-
-      @jobs_by_class[job.klass.to_s] ||= []
-      @jobs_by_class[job.klass.to_s] << job
-      @jobs_by_id[id] = job
-      job.incoming.each do |from|
-        @deps << { from: from, to: id }
+
+  class Workflow::Builder
+
+    def initialize(workflow, *args, &block)
+      @workflow = workflow
+      @deps = []
+      @jobs_by_class = {}
+      @jobs_by_id = {}
+
+      @workflow.jobs_config.each_pair do |id, job_hash|
+        job = Burstflow::Job.from_hash(@workflow, job_hash)
+
+        @jobs_by_class[job.klass.to_s] ||= []
+        @jobs_by_class[job.klass.to_s] << job
+        @jobs_by_id[id] = job
+        job.incoming.each do |from|
+          @deps << { from: from, to: id }
+        end
+
+        job.outgoing.each do |to|
+          @deps << { from: id, to: to }
+        end
+
+        @deps.uniq!
       end
 
-      job.outgoing.each do |to|
-        @deps << { from: id, to: to }
+      instance_exec *args, &block
+      resolve_dependencies
       end
 
-      @deps.uniq!
-    end
+    def run(klass, opts = {})
+      opts = opts.with_indifferent_access
 
-    instance_exec *args, &block
-    resolve_dependencies
-  end
+      before_deps = opts.delete(:before) || []
+      after_deps = opts.delete(:after) || []
 
-  def run(klass, opts = {})
-    opts = opts.with_indifferent_access
+      job = klass.new(@workflow, opts)
 
-    before_deps = opts.delete(:before) || []
-    after_deps = opts.delete(:after) || []
+      [*before_deps].each do |dep|
+        @deps << { from: job.id, to: dep.to_s }
+      end
 
-    job = klass.new(@workflow, opts)
+      [*after_deps].each do |dep|
+        @deps << { from: dep.to_s, to: job.id }
+      end
 
-    [*before_deps].each do |dep|
-      @deps << { from: job.id, to: dep.to_s }
-    end
+      @jobs_by_class[klass.to_s] ||= []
+      @jobs_by_class[klass.to_s] << job
 
-    [*after_deps].each do |dep|
-      @deps << { from: dep.to_s, to: job.id }
-    end
+      raise 'Job id duplication' if @jobs_by_id.key?(job.id)
 
-    @jobs_by_class[klass.to_s] ||= []
-    @jobs_by_class[klass.to_s] << job
+      @jobs_by_id[job.id] = job
 
-    raise "Job id duplication" if @jobs_by_id.key?(job.id)
-    @jobs_by_id[job.id] = job
+      job.id
+    end
 
-    job.id
-  end
+    def find_job(id_or_klass)
+      id = if @jobs_by_id.key?(id_or_klass)
+             id_or_klass
+           else
+             jobs = @jobs_by_class[id_or_klass.to_s]
 
-  def find_job id_or_klass
-    id = if @jobs_by_id.key?(id_or_klass)
-      id_or_klass
-    else
-      jobs = @jobs_by_class[id_or_klass.to_s]
+             raise "No job with #{id_or_klass} klass or id found" if jobs.count == 0
+             raise "Duplicated jobs with #{id_or_klass} klass or id detected" if jobs.count > 1
 
-      raise "No job with #{id_or_klass.to_s} klass or id found" if jobs.count == 0
-      raise "Duplicated jobs with #{id_or_klass.to_s} klass or id detected" if jobs.count > 1
+             jobs.first.id
+      end
 
-      jobs.first.id
+      @jobs_by_id[id]
     end
 
-    @jobs_by_id[id]
-  end
-
-  def resolve_dependencies
-    @deps.each do |dependency|
-      from = find_job(dependency[:from].to_s)
-      to   = find_job(dependency[:to].to_s)
+    def resolve_dependencies
+      @deps.each do |dependency|
+        from = find_job(dependency[:from].to_s)
+        to   = find_job(dependency[:to].to_s)
 
-      to.incoming << from.id
-      from.outgoing << to.id
+        to.incoming << from.id
+        from.outgoing << to.id
 
-      to.incoming.uniq!
-      from.outgoing.uniq!
+        to.incoming.uniq!
+        from.outgoing.uniq!
+      end
     end
-  end
 
-  def as_json
-    @jobs_by_id.each_with_object({}) do |(id, job), json|
-      json[job.id] = job.as_json
+    def as_json
+      @jobs_by_id.each_with_object({}) do |(_id, job), json|
+        json[job.id] = job.as_json
+      end
     end
+
   end
 
 end
-end

data/lib/burstflow/workflow/callbacks.rb

@@ -1,66 +1,60 @@
 module Burstflow::Workflow::Callbacks
+
   extend  ActiveSupport::Concern
   include ActiveSupport::Callbacks
 
   included do
-
     define_callbacks :failure, :finish, :suspend, :resume
-
   end
 
   class_methods do
-
     def before_failure(*filters, &blk)
       set_callback(:failure, :before, *filters, &blk)
     end
-  
+
     def after_failure(*filters, &blk)
       set_callback(:failure, :after, *filters, &blk)
     end
-    
+
     def around_failure(*filters, &blk)
       set_callback(:failure, :around, *filters, &blk)
     end
 
-
     def before_finish(*filters, &blk)
       set_callback(:finish, :before, *filters, &blk)
     end
-  
+
     def after_finish(*filters, &blk)
       set_callback(:finish, :after, *filters, &blk)
     end
-    
+
     def around_finish(*filters, &blk)
       set_callback(:finish, :around, *filters, &blk)
     end
 
-
     def before_suspend(*filters, &blk)
       set_callback(:suspend, :before, *filters, &blk)
     end
-  
+
     def after_suspend(*filters, &blk)
       set_callback(:suspend, :after, *filters, &blk)
     end
-    
+
     def around_suspend(*filters, &blk)
       set_callback(:suspend, :around, *filters, &blk)
     end
 
-
     def before_resume(*filters, &blk)
       set_callback(:resume, :before, *filters, &blk)
     end
-  
+
     def after_resume(*filters, &blk)
       set_callback(:resume, :after, *filters, &blk)
     end
-    
+
     def around_resume(*filters, &blk)
       set_callback(:resume, :around, *filters, &blk)
     end
-
   end
 
-end
+end

data/lib/burstflow/workflow/configuration.rb

@@ -1,55 +1,56 @@
 module Burstflow
 
-module Workflow::Configuration
-  extend ActiveSupport::Concern
+  module Workflow::Configuration
 
-  class JSONBWithIndifferentAccess
+    extend ActiveSupport::Concern
 
-    def self.dump(hash)
-      hash.as_json
-    end
+    class JSONBWithIndifferentAccess
+
+      def self.dump(hash)
+        hash.as_json
+      end
+
+      def self.load(hash)
+        hash ||= {}
+        hash = JSON.parse(hash) if hash.is_a? String
+        hash.with_indifferent_access
+      end
 
-    def self.load(hash)
-      hash ||= {}
-      hash = JSON.parse(hash) if hash.is_a? String
-      hash.with_indifferent_access
     end
 
-  end
+    included do |_klass|
+      serialize :flow, JSONBWithIndifferentAccess
 
-  included do |_klass|
-    serialize :flow, JSONBWithIndifferentAccess
-    
-    def configure(*args)
-      builder = Builder.new()
-      builder.instance_exec *args, &self.class.configuration
-      builder.resolve_dependencies
-      builder.as_json
+      def configure(*args)
+        builder = Builder.new
+        builder.instance_exec *args, &self.class.configuration
+        builder.resolve_dependencies
+        builder.as_json
+      end
     end
-  end
 
-  class_methods do
-    def define_flow_attributes(*keys)
-      keys.each do |key|
-        define_method key.to_sym do
-          return flow[key.to_s]
-        end
+    class_methods do
+      def define_flow_attributes(*keys)
+        keys.each do |key|
+          define_method key.to_sym do
+            return flow[key.to_s]
+          end
 
-        define_method "#{key}=".to_sym do |v|
-          return flow[key.to_s] = v
+          define_method "#{key}=".to_sym do |v|
+            return flow[key.to_s] = v
+          end
         end
       end
-    end
 
-    def configure(&block)
-      @configuration = block
-    end
+      def configure(&block)
+        @configuration = block
+      end
 
-    def configuration
-      @configuration
+      def configuration
+        @configuration
+      end
     end
+
   end
 
 end
-
-end

data/lib/burstflow/workflow/exception.rb

@@ -1,8 +1,10 @@
 class Burstflow::Workflow::InternalError < ::RuntimeError
+
   attr_accessor :workflow
 
   def initialize(workflow, message)
     @workflow = workflow
     super(message)
   end
-end
+
+end

data/lib/generators/burstflow/install/install_generator.rb

@@ -2,11 +2,14 @@ require 'rails/generators'
 require 'rails/generators/migration'
 
 module Burstflow
+
   module Generators
+
     class InstallGenerator < ::Rails::Generators::Base
+
       include Rails::Generators::Migration
-      source_root File.expand_path('../templates', __FILE__)
-      desc "Add the migrations for Burstflow"
+      source_root File.expand_path('templates', __dir__)
+      desc 'Add the migrations for Burstflow'
 
       def self.next_migration_number(path)
         next_migration_number = current_migration_number(path) + 1
@@ -14,9 +17,12 @@ module Burstflow
       end
 
       def copy_migrations
-        migration_template "create_workflow.rb",
-          "db/migrate/create_workflow.rb"
+        migration_template 'create_workflow.rb',
+                           'db/migrate/create_workflow.rb'
       end
+
     end
+
   end
-end
+
+end

data/spec/builder_spec.rb

@@ -6,23 +6,23 @@ describe Burstflow::Workflow::Builder do
     BuilderJob2 = Class.new(Burstflow::Job)
     BuilderJob3 = Class.new(Burstflow::Job)
 
-    let(:workflow){double(:workflow, id: 'id1', jobs_config: {})}
+    let(:workflow){ double(:workflow, id: 'id1', jobs_config: {}) }
 
     it 'without dependencies' do
-      builder = Burstflow::Workflow::Builder.new workflow do 
+      builder = Burstflow::Workflow::Builder.new workflow do
         $jobid1 = run BuilderJob1, params: { param1: true }
       end
 
       flow = builder.as_json
       expect(flow.count).to eq 1
 
-      expect(flow[$jobid1]).to include(:id, :incoming, :outgoing, workflow_id: 'id1', params: {'param1' => true})
+      expect(flow[$jobid1]).to include(:id, :incoming, :outgoing, workflow_id: 'id1', params: { 'param1' => true })
     end
 
     it 'with dependencies' do
       builder = Burstflow::Workflow::Builder.new workflow, :arg1, :arg2 do |arg1, arg2|
-        $jobid1 = run BuilderJob1, params: { param1: true, arg: arg1}
-        $jobid2 = run BuilderJob2, params: { param2: true, arg: arg2}, after: BuilderJob1
+        $jobid1 = run BuilderJob1, params: { param1: true, arg: arg1 }
+        $jobid2 = run BuilderJob2, params: { param2: true, arg: arg2 }, after: BuilderJob1
         $jobid3 = run BuilderJob3, before: BuilderJob2, after: $jobid1
         $jobid4 = run BuilderJob3, after: $jobid3
       end
@@ -30,34 +30,33 @@ describe Burstflow::Workflow::Builder do
       flow = builder.as_json
       expect(flow.count).to eq 4
 
-      expect(flow[$jobid1]).to include(:id, 
-        klass: BuilderJob1.to_s,
-        incoming: [],
-        outgoing: [$jobid2, $jobid3],
-        workflow_id: 'id1',
-        params: {'param1' => true, 'arg' => :arg1})
+      expect(flow[$jobid1]).to include(:id,
+                                       klass: BuilderJob1.to_s,
+                                       incoming: [],
+                                       outgoing: [$jobid2, $jobid3],
+                                       workflow_id: 'id1',
+                                       params: { 'param1' => true, 'arg' => :arg1 })
 
       expect(flow[$jobid2]).to include(:id,
-        klass: BuilderJob2.to_s,
-        incoming: [$jobid1, $jobid3],
-        outgoing: [],
-        workflow_id: 'id1',
-        params: {'param2' => true, 'arg' => :arg2})
+                                       klass: BuilderJob2.to_s,
+                                       incoming: [$jobid1, $jobid3],
+                                       outgoing: [],
+                                       workflow_id: 'id1',
+                                       params: { 'param2' => true, 'arg' => :arg2 })
 
       expect(flow[$jobid3]).to include(:id,
-        klass: BuilderJob3.to_s,
-        incoming: [$jobid1],
-        outgoing: [$jobid2, $jobid4],
-        workflow_id: 'id1',
-        params: nil)
+                                       klass: BuilderJob3.to_s,
+                                       incoming: [$jobid1],
+                                       outgoing: [$jobid2, $jobid4],
+                                       workflow_id: 'id1',
+                                       params: nil)
 
       expect(flow[$jobid4]).to include(:id,
-        klass: BuilderJob3.to_s,
-        incoming: [$jobid3],
-        outgoing: [],
-        workflow_id: 'id1',
-        params: nil)
+                                       klass: BuilderJob3.to_s,
+                                       incoming: [$jobid3],
+                                       outgoing: [],
+                                       workflow_id: 'id1',
+                                       params: nil)
     end
-
   end
 end