rao-service_chain 0.0.38.pre → 0.0.43.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e5e8c17080f335d7dca5868c7ebb9b634ac4875dc3f0da34a980636bfefcb73
-  data.tar.gz: b0e57dd2954bfbbf1f4b2baeacc1f21a7f4e5163296547eea4073b61ad5ef65b
+  metadata.gz: 1ed5e8922014983a8ba799164bcd4531d2d433aa7a5136a48e4d7f3bda26c738
+  data.tar.gz: ca3cfb9f4572e269291863ac884ce32c59e608b0083b60037fcf7258d4afd7a1
 SHA512:
-  metadata.gz: 85191653db150a484fc6ec8af2146fc8d1d042711e775a45243ce7165a543753e1c18f3f06bba02b79151b0c8c1de27312837a5a42cd7d477ebf638084880907
-  data.tar.gz: 2b31b9257e8b961eca6f51c27084d72471b39dc8aa8b15a329f9568f137227f0e0b73902d89d5c455c0306ff0c89e17006d6a246b6fc4896ed9fe97c180bdf4a
+  metadata.gz: bc7b363310554f003fd52cc890d93aab7746d25d15ae1a8386ba5bca27c8589f39fc9345a371daa4a050bcb40a835460c316a8d455f0a4e19c8830014a6776b4
+  data.tar.gz: 95a9504526c028767e6978b9c5f9f78b477e422214ec1e9d02de27a21566024176b7f2377b02f7f368e1d4af9e02f9c8037147f6cebb05c104a575aaf5170755

data/app/service_chains/rao/service_chain/aasm.rb

@@ -0,0 +1,6 @@
+module Rao
+  module ServiceChain
+    module Aasm
+    end
+  end
+end

data/app/service_chains/rao/service_chain/aasm/base.rb

@@ -0,0 +1,264 @@
+
+module Rao
+  module ServiceChain
+    module Aasm
+      class Base
+        include ::AASM
+
+        def initialize(options = {})
+          options.each do |k,v|
+            send("#{k}=", v)
+          end
+        end
+
+        module ServiceConcern
+          extend ActiveSupport::Concern
+
+          class_methods do
+            def service_module_name
+              nil
+            end
+          end
+
+          def service_class_to_state(service_class)
+            service_class.name.demodulize.underscore.to_sym
+          end
+
+          def state_to_service_class(state)
+            "#{self.class.service_module_name}#{state.to_s.camelize}".constantize
+          end
+        end
+
+        include ServiceConcern
+
+        module StepConcern
+          extend ActiveSupport::Concern
+
+          def actual_step=(service_class)
+            aasm.current_state = service_class_to_state(service_class)
+          end
+
+          def actual_step
+            return nil if %i(started finished).include?(aasm.current_state)
+            wrap(
+              state_to_service_class(aasm.current_state),
+              completed_if: aasm.states.find { |s| s.name == aasm.current_state }.options[:completed_if],
+              router: aasm.states.find { |s| s.name == aasm.current_state }.options[:router],
+              url: aasm.states.find { |s| s.name == aasm.current_state }.options[:url],
+            )
+          end
+
+          def previous_steps 
+            current_state = aasm.current_state
+            o = []
+            i = 0
+            while(i < 1000) do
+              previous_event = aasm.events.select{ |e| e.name == :previous }.first
+              return [] unless previous_event.respond_to?(:transitions)
+              targets = previous_event.transitions.select{ |t|
+              # targets = aasm.events(permitted: true).select{ |e| e.name == :next }.first.transitions.select{ |t|
+                t.from == current_state
+              }.select{ |t|
+                guards = t.instance_variable_get(:@guards)
+                if guards.empty?
+                  true
+                else
+                  guards.map { |g| send(g) }.all?
+                end
+              }.map { |t|
+                {
+                  t.to => {
+                    display: (t.options[:display].presence || -> { true }),
+                    completed_if: aasm.states.find { |s| s.name == t.to }.options[:completed_if],
+                    router: aasm.states.find { |s| s.name == t.to }.options[:router],
+                    url: aasm.states.find { |s| s.name == t.to }.options[:url],
+                  } 
+                }
+              }
+              break if targets.empty? || %i(started finished).include?(targets.first.first[0])
+              o << wrap(state_to_service_class(targets.first.first[0]), targets.first.first[1])
+              current_state = targets.first.first[0]
+              i = i + 1
+            end
+            o.reverse.compact
+          end
+
+          def next_steps
+            current_state = aasm.current_state
+            o = []
+            i = 0
+            while(i < 1000) do
+              previous_event = aasm.events.select{ |e| e.name == :next }.first
+              return [] unless previous_event.respond_to?(:transitions)
+              targets = previous_event.transitions.select{ |t|
+              # targets = aasm.events(permitted: true).select{ |e| e.name == :next }.first.transitions.select{ |t|
+                t.from == current_state
+              }.select{ |t|
+                guards = t.instance_variable_get(:@guards)
+                if guards.empty?
+                  true
+                else
+                  guards.map { |g| send(g) }.all?
+                end
+              }.map { |t|
+                {
+                  t.to => {
+                    display: (t.options[:display].presence || -> { true }),
+                    completed_if: aasm.states.find { |s| s.name == t.to }.options[:completed_if],
+                    router: aasm.states.find { |s| s.name == t.to }.options[:router],
+                    url: aasm.states.find { |s| s.name == t.to }.options[:url],
+                  } 
+                }
+              }
+              break if targets.empty? || %i(started finished).include?(targets.first.first[0])
+              o << wrap(state_to_service_class(targets.first.first[0]), targets.first.first[1])
+              current_state = targets.first.first[0]
+              i = i + 1
+            end
+            o.compact
+          end
+
+          def steps
+            # aasm.states.map(&:name).map { |s| wrap(state_to_service_class(s)) }
+            o = []
+
+            #walk backwards
+            # current_state = aasm.current_state
+            # i = 0
+            # while(i < 1000) do
+            #   targets = aasm.events.select{ |e| e.name == :previous }.first.transitions.select{ |t|
+            #   # targets = aasm.events(permitted: true).select{ |e| e.name == :previous }.first.transitions.select{ |t|
+            #     t.from == current_state
+            #   }.select{ |t|
+            #     guards = t.instance_variable_get(:@guards)
+            #     if guards.empty?
+            #       true
+            #     else
+            #       guards.map { |g| send(g) }.all?
+            #     end
+            #   }.map { |t| t.to }
+            #   break if targets.empty?
+            #   o << wrap(state_to_service_class(targets.first))
+            #   current_state = targets.first
+            #   i = i + 1
+            # end
+
+            # o.reverse!
+
+            o << self.previous_steps
+
+            # add actual state
+            o << self.actual_step unless self.actual_step.nil?
+            # o << wrap(state_to_service_class(aasm.current_state))
+
+            # walk forward
+            o << self.next_steps
+            # current_state = aasm.current_state
+            # i = 0
+            # while(i < 1000) do
+            #   targets = aasm.events.select{ |e| e.name == :next }.first.transitions.select{ |t|
+            #   # targets = aasm.events(permitted: true).select{ |e| e.name == :next }.first.transitions.select{ |t|
+            #     t.from == current_state
+            #   }.select{ |t|
+            #     guards = t.instance_variable_get(:@guards)
+            #     if guards.empty?
+            #       true
+            #     else
+            #       guards.map { |g| send(g) }.all?
+            #     end
+            #   }.map { |t| {t.to => { display: (t.options[:display].presence || -> { true }) } } }
+            #   break if targets.empty?
+            #   o << wrap(state_to_service_class(targets.first.first[0]), targets.first.first[1])
+            #   current_state = targets.first.first[0]
+            #   i = i + 1
+            # end
+            o.flatten
+          end
+
+          def step_count
+            steps.size
+          end
+
+          def completed_steps
+            self.steps.collect { |s| s.completed? ? s : nil }.compact
+          end
+    
+          def pending_steps
+            self.steps.collect { |s| s.pending? ? s : nil }.compact
+          end
+
+          private
+
+          def wrap(service, options = {})
+            wrapper_class = Rao::ServiceChain::Step::Base
+            if service.is_a?(wrapper_class)
+                service
+            else
+              wrapper_class.new(options.merge(service: service, chain: self))
+            end
+          end
+        end
+
+        include StepConcern
+
+        module StepOrderConcern
+          extend ActiveSupport::Concern
+
+          def before_actual?(step)
+            return false if self.actual_step.nil?
+            return false if (si = step_index(wrap(step))).nil?
+            self.actual_step_index > si
+          end
+    
+          def after_actual?(step)
+            return false if self.actual_step.nil?
+            return false if (si = step_index(wrap(step))).nil?
+            self.actual_step_index < si
+          end
+
+          def step_index(step)
+            self.steps.map(&:service).index(step.try(:service))
+          end
+
+          def actual_step_index
+            self.steps.map(&:service).index(self.actual_step.try(:service))
+          end
+
+          def next_step
+            self.next_steps.first
+            # return nil if self.actual_step_index.nil?
+            # return nil if self.actual_step_index + 1 >= self.step_count
+            # self.steps[self.actual_step_index + 1]
+          end
+
+          def previous_step
+            self.previous_steps.last
+            # return nil if self.actual_step_index.nil?
+            # return nil if self.actual_step_index - 1 < 0
+            # self.steps[self.actual_step_index - 1]
+          end
+
+          def next_step_url(options = {})
+            context = options.delete(:context)
+            self.next_step.url(context)
+          end
+        end
+
+        include StepOrderConcern
+
+        module SerializationConcern
+          extend ActiveSupport::Concern
+
+          def to_hash(context = nil)
+            {
+              actual_step: self.actual_step.to_hash(context),
+              steps: self.steps.map { |s| s.to_hash(context) }
+            }
+          end
+        end
+
+        include SerializationConcern
+      end
+    end
+  end
+end

data/app/service_chains/rao/service_chain/base~.rb

@@ -0,0 +1,151 @@
+module Rao
+  module ServiceChain
+      class Base
+      attr_accessor :steps
+      attr_accessor :actual_step
+
+      def initialize(options = {})
+        options.each do |key, value|
+          self.send("#{key}=", value)
+        end
+        if @actual_step.present?
+          actual_service = unwrap(@actual_step)
+          @actual_step = find_step_by_service(actual_service)
+        end
+      end
+
+      def wrap_actual_step!
+        @actual_step = wrap(@actual_step)
+      end
+
+      def steps=(steps)
+        @steps = steps.map { |s| wrap(s) }
+      end
+
+      def steps
+        raise "Child class responsiblity"
+      end
+
+      def step_index(step)
+        self.steps.map(&:service).index(step.try(:service))
+      end
+      
+      def service_index(service)
+        self.steps.map(&:service).index(service)
+      end
+
+      def find_step_by_service(service)
+        self.steps[(service_index(service))]
+      end
+
+      def actual_step_index
+        self.steps.map(&:service).index(self.actual_step.try(:service))
+      end
+
+      def step_count
+        self.steps.size
+      end
+
+      def previous_step_index
+        self.steps.map(&:service).index(self.previous_step.try(:service))
+      end
+
+      def next_step_index
+        self.steps.map(&:service).index(self.next_step.try(:service))
+      end
+
+      def previous_step
+        return nil if self.actual_step_index.nil?
+        return nil if self.actual_step_index - 1 < 0
+        self.steps[self.actual_step_index - 1]
+      end
+
+      def previous_steps
+        return [] if self.actual_step_index.nil?
+        return [] if self.actual_step_index == 0
+        self.steps[0..(self.actual_step_index - 1)]
+      end
+
+      def next_step
+        if self.actual_step.try(:next_step).respond_to?(:call)
+          find_step_by_service(self.actual_step.next_step.call(self.actual_step))
+        else
+          return nil if self.actual_step_index.nil?
+          return nil if self.actual_step_index + 1 >= self.step_count
+          self.steps[self.actual_step_index + 1]
+        end
+      end
+
+      def next_steps
+        return [] if self.actual_step_index.nil?
+        self.steps[(self.actual_step_index + 1)..-1]
+      end
+
+      def next_step?
+        !!next_step
+      end
+
+      def previous_step?
+        !!previous_step
+      end
+
+      def next_step_url(options = {})
+        context = options.delete(:context)
+        self.next_step.url(context)
+      end
+
+      def steps_with_urls(context)
+        self.steps.map { |s| s.url(context); s }
+      end
+
+      def to_hash(context = nil)
+        {
+          actual_step: self.actual_step.to_hash(context),
+          steps: self.steps.map { |s| s.to_hash(context) }
+        }
+      end
+
+      def completed_steps
+        self.steps.collect { |s| s.completed? ? s : nil }.compact
+      end
+
+      def pending_steps
+        self.steps.collect { |s| s.pending? ? s : nil }.compact
+      end
+
+      def before_actual?(step)
+        return false if self.actual_step.nil?
+        return false if (si = step_index(wrap(step))).nil?
+        self.actual_step_index > si
+      end
+
+      def after_actual?(step)
+        return false if self.actual_step.nil?
+        return false if (si = step_index(wrap(step))).nil?
+        self.actual_step_index < si
+      end
+
+      private
+
+      def wrap(service, options = {})
+        if service.is_a?(wrapper_base_class)
+           service
+        else
+          wrapper_base_class.new(options.merge(service: service, chain: self))
+        end
+      end
+
+      def unwrap(step_or_service)
+        if step_or_service.is_a?(wrapper_base_class)
+          step_or_service.service
+        else
+          step_or_service
+        end
+      end
+
+      def wrapper_base_class
+        Rao::ServiceChain::Step::Base
+      end
+    end
+  end
+end

data/app/service_steps/rao/service_chain/step/base.rb

@@ -2,7 +2,7 @@ module Rao
   module ServiceChain
     module Step
       class Base
-        attr_accessor :service, :service_name, :label, :chain
+        attr_accessor :service, :service_name, :label, :chain, :router
 
         def initialize(options = {})
           @service = options.delete(:service)
@@ -12,12 +12,13 @@ module Rao
           @service_name = @service.try(:name)
           @label = service.try(:model_name).try(:human)
           @url = options.delete(:url)
+          @router = options.delete(:router) || :main_app
         end
 
         def url(context = nil)
           return nil if context.nil?
           return context.instance_exec(@service, &@url) if @url.respond_to?(:call)
-          @url ||= context.url_for([:new, @service, only_path: true])
+          @url ||= context.send(router).url_for([:new, @service, only_path: true])
         end
 
         def completed?
@@ -25,6 +26,25 @@ module Rao
           @chain.instance_exec(@service, &@completed_if)
         end
 
+        def render_as_completed?(options = {})
+          render_previous_steps_as_pending = options.dig(:previous_steps, :render_as_pending)
+          render_next_step_as_pending = options.dig(:next_steps, :render_as_pending)
+
+          if @chain.before_actual?(self)
+            if render_previous_steps_as_pending
+              completed?
+            else
+              true
+            end
+          else
+            if render_next_step_as_pending
+              false
+            else
+              completed?
+            end
+          end
+        end
+        
         def pending?
           !completed?
         end

data/app/view_helpers/rao/service_chain/application_view_helper.rb

@@ -20,17 +20,23 @@ module Rao
       #
       def render_progress(service_chain, options = {})
         return if service_chain.nil?
-
-        options.reverse_merge!(
-          theme: :bootstrap4,
-          link_next_steps: true,
-          link_actual_step: false,
-          link_previous_steps: true
-        )
+        
+        options = default_options.deep_merge(options)
         theme = options.delete(:theme)
 
         c.render partial: "rao/service_chain/application_view_helper/render_progress/#{theme}", locals: { service_chain: service_chain, options: options }
       end
+
+      private
+
+      def default_options
+        {
+          theme: :bootstrap4,
+          next_steps: { render_as_pending: false, link: true },
+          actual_step: { link: false },
+          previous_steps: { render_as_pending: true, link: true }
+        }
+      end
     end
   end
 end

data/app/views/rao/service_chain/application_view_helper/render_progress/_bootstrap4.html.haml

@@ -8,19 +8,19 @@
             %span.wizard-step-marker.rounded-circle.bg-primary.text-white
               %i.fas.fa-play
             %span.wizard-step-label
-              - if options[:link_actual_step]
+              - if options.dig(:actual_step, :link)
                 = link_to(step.label, step.url(self))
               - else
                 = step.label
           - else
-            - if step.completed?
-              %span.wizard-step-marker.rounded-circle.bg-success.text-white
+            - if step.render_as_completed?(options)
+              %span.wizard-step-marker.rounded-circle.bg-success.text-white.render-completed
                 %i.fas.fa-check
             - else
-              %span.wizard-step-marker.rounded-circle.bg-secondary.text-white
+              %span.wizard-step-marker.rounded-circle.bg-secondary.text-white.render-pending
                 %i.fas.fa-circle
             %span.wizard-step-label
-              - if (service_chain.before_actual?(step) && options[:link_previous_steps]) || (service_chain.after_actual?(step) && options[:link_next_steps])
+              - if (service_chain.before_actual?(step) && options.dig(:previous_steps, :link)) || (service_chain.after_actual?(step) && options.dig(:next_steps, :link))
                 = link_to(step.label, step.url(self))
               - else
                 = step.label

data/lib/rao-service_chain.rb

@@ -1,3 +1,4 @@
+require "aasm"
 require "haml-rails"
 
 require "rao"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rao-service_chain
 version: !ruby/object:Gem::Version
-  version: 0.0.38.pre
+  version: 0.0.43.pre
 platform: ruby
 authors:
 - Roberto Vasquez Angel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-13 00:00:00.000000000 Z
+date: 2020-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: aasm
+  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: haml-rails
   requirement: !ruby/object:Gem::Requirement
@@ -164,7 +178,10 @@ files:
 - app/assets/stylesheets/rao/service_chain/application.css
 - app/assets/stylesheets/rao/service_chain/application/wizard.css
 - app/concerns/rao/service/chain/controller_concern.rb
+- app/service_chains/rao/service_chain/aasm.rb
+- app/service_chains/rao/service_chain/aasm/base.rb
 - app/service_chains/rao/service_chain/base.rb
+- app/service_chains/rao/service_chain/base~.rb
 - app/service_steps/rao/service_chain/step/base.rb
 - app/view_helpers/rao/service_chain/application_view_helper.rb
 - app/views/rao/service_chain/application_view_helper/render_progress/_bootstrap4.html.haml
@@ -195,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Service Chains for Ruby on Rails.