rao-service_chain 0.0.41.pre → 0.0.42.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2672cfbd5062d63ae6ef9537ac6fbb32f5520a8be5f84a9fc9cdc28c2fa37739
-  data.tar.gz: ab9547bf5879c5f9b85e6da8dca62bf4b8a468a469f4d50cc251c11002b03fec
+  metadata.gz: eef27fc8f2a5fcc1a1d6434f39519976f2aa24f2736368713aafa4c02c030f2d
+  data.tar.gz: d3777a94d300f861958d7dfef5ab83ff4a39d47ed30f62328a6f11ad9b88520c
 SHA512:
-  metadata.gz: d90e73e47d5d0c890a5a6e6ffa72200b568276bf79031c03ea87434ab5fcf351149f4d43e88c193da345b24c6346b773c5e4abc01d397cd7951e6d2c0a89581d
-  data.tar.gz: e6343221aa5c5d8553acfd5b37b40ac78706c9c1e855cbd82c2329ea763f59da2df1d78065bb0125b744995b94c7ca53f75615ffec83e47667e66504c3f0043a
+  metadata.gz: 37d0c350c1c86ed978ebabf283ff6d8090a6e8b6e3fd1ab48b10f45e8730486c83858464d231e8e3f02da0435ce59c22793d9c194b538014b5a0f2ea335ead01
+  data.tar.gz: c8a355694e8aa24995ae03210522d6db0dfb1ff8d696d2ce93e38558b871b98e4da685f91bd90deae04a60f10c32552922849d5bed920d6b8a811ac1a9a3590b

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/aasm.rb

@@ -0,0 +1,6 @@
+module Rao
+  module ServiceChain
+    module Aasm
+    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?

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.41.pre
+  version: 0.0.42.pre
 platform: ruby
 authors:
 - Roberto Vasquez Angel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-24 00:00:00.000000000 Z
+date: 2020-05-20 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.1.2
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Service Chains for Ruby on Rails.