yaso 1.0.0pre

data/benchmark/step/trailblazer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class TrailblazerStepsService < TrailblazerService
+  step :one
+  step :two
+  step :three
+  step :four
+  step :five
+  step :six
+  step :seven
+  step :eight
+  step :nine
+  step :ten
+
+  def one(ctx, **)
+    ctx[:one] = true
+  end
+
+  def two(ctx, **)
+    ctx[:two] = true
+  end
+
+  def three(ctx, **)
+    ctx[:three] = true
+  end
+
+  def four(ctx, **)
+    ctx[:four] = true
+  end
+
+  def five(ctx, **)
+    ctx[:five] = true
+  end
+
+  def six(ctx, **)
+    ctx[:six] = true
+  end
+
+  def seven(ctx, **)
+    ctx[:seven] = true
+  end
+
+  def eight(ctx, **)
+    ctx[:eight] = true
+  end
+
+  def nine(ctx, **)
+    ctx[:nine] = true
+  end
+
+  def ten(ctx, **)
+    ctx[:ten] = true
+  end
+end
+
+module TrailblazerMacro
+  # rubocop:disable Naming/MethodName
+  def self.CallableStep(key:, value:)
+    id = :"CallableStep.#{key}"
+    step = lambda do |ctx, **|
+      ctx[key] = value
+      return true if ctx[key]
+
+      ctx[:"result.#{id}"] = Trailblazer::Operation::Result.new(false, {})
+      false
+    end
+    task = Trailblazer::Activity::TaskBuilder::Binary(step)
+    { task: task, id: id }
+  end
+  # rubocop:enable Naming/MethodName
+end
+
+class TrailblazerCallablesService < TrailblazerService
+  step TrailblazerMacro::CallableStep(key: :one, value: true)
+  step TrailblazerMacro::CallableStep(key: :two, value: true)
+  step TrailblazerMacro::CallableStep(key: :three, value: true)
+  step TrailblazerMacro::CallableStep(key: :four, value: true)
+  step TrailblazerMacro::CallableStep(key: :five, value: true)
+  step TrailblazerMacro::CallableStep(key: :six, value: true)
+  step TrailblazerMacro::CallableStep(key: :seven, value: true)
+  step TrailblazerMacro::CallableStep(key: :eight, value: true)
+  step TrailblazerMacro::CallableStep(key: :nine, value: true)
+  step TrailblazerMacro::CallableStep(key: :ten, value: true)
+end

data/benchmark/step/yaso.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class YasoStepsService < YasoService
+  step :one
+  step :two
+  step :three
+  step :four
+  step :five
+  step :six
+  step :seven
+  step :eight
+  step :nine
+  step :ten
+
+  def one(ctx, **)
+    ctx[:one] = true
+  end
+
+  def two(ctx, **)
+    ctx[:two] = true
+  end
+
+  def three(ctx, **)
+    ctx[:three] = true
+  end
+
+  def four(ctx, **)
+    ctx[:four] = true
+  end
+
+  def five(ctx, **)
+    ctx[:five] = true
+  end
+
+  def six(ctx, **)
+    ctx[:six] = true
+  end
+
+  def seven(ctx, **)
+    ctx[:seven] = true
+  end
+
+  def eight(ctx, **)
+    ctx[:eight] = true
+  end
+
+  def nine(ctx, **)
+    ctx[:nine] = true
+  end
+
+  def ten(ctx, **)
+    ctx[:ten] = true
+  end
+end
+
+class YasoCallablesService < YasoService
+  step CallableStep, key: :one, value: true
+  step CallableStep, key: :two, value: true
+  step CallableStep, key: :three, value: true
+  step CallableStep, key: :four, value: true
+  step CallableStep, key: :five, value: true
+  step CallableStep, key: :six, value: true
+  step CallableStep, key: :seven, value: true
+  step CallableStep, key: :eight, value: true
+  step CallableStep, key: :nine, value: true
+  step CallableStep, key: :ten, value: true
+end

data/lefthook.yml

@@ -0,0 +1,5 @@
+pre-commit:
+  parallel: true
+  commands:
+    rubocop:
+      run: bundle exec rubocop

data/lib/yaso/context.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Yaso
+  class Context
+    attr_writer :success
+
+    def initialize(kwargs)
+      @success = true
+      @data = kwargs
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def to_h
+      @data.dup
+    end
+
+    def to_h!
+      @data
+    end
+
+    def success?
+      @success
+    end
+
+    def failure?
+      !@success
+    end
+  end
+end

data/lib/yaso/errors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Yaso
+  class Error < StandardError; end
+
+  class StepIsNotImplementedError < Error
+    def initialize(klass, step)
+      super("#{klass}##{step} step is not implemented")
+    end
+  end
+
+  class InvalidFirstStepError < Error
+    def initialize(category)
+      super("#{category.to_s.capitalize} cannot be the first step")
+    end
+  end
+
+  class UnhandledSwitchCaseError < Error
+    def initialize(klass)
+      super("Unhandled switch case in #{klass}")
+    end
+  end
+end

data/lib/yaso/invokable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Yaso
+  class Invokable
+    METHOD = :method
+    CALLABLE = :callable
+    YASO = :yaso
+
+    class << self
+      def call(object, options: {}, **)
+        type = object_type(object)
+        invokable = case type
+                    when YASO then ->(context, _) { object.call(context.clone).success? }
+                    when CALLABLE then ->(context, _, &block) { object.call(context, **options, &block) }
+                    else ->(context, instance, &block) { instance.send(object, context, **context.to_h!, &block) }
+                    end
+        [type, invokable]
+      end
+
+      private
+
+      def object_type(object)
+        return Invokable::METHOD unless object.is_a?(Class)
+
+        object < ::Yaso::Service ? Invokable::YASO : Invokable::CALLABLE
+      end
+    end
+  end
+end

data/lib/yaso/logic/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Base
+      attr_reader :name, :on_success, :on_failure
+
+      def initialize(name:, invokable:, **options)
+        @name = name
+        @invokable = invokable
+        @fast = options[:fast]
+        @on_success = options[:on_success]
+        @on_failure = options[:on_failure]
+      end
+
+      def call(_, _)
+        raise NotImplementedError
+      end
+
+      def add_next_step(step)
+        @next_step = step unless @fast == true || @fast == :success
+      end
+
+      def add_failure(failure)
+        @failure = failure unless @fast == true || @fast == :failure
+      end
+    end
+  end
+end

data/lib/yaso/logic/classic.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Classic
+      def self.call(klass, steps)
+        new(klass, steps).call
+      end
+
+      def initialize(klass, steps)
+        @klass = klass
+        @steps = steps
+        @step_builder = StepBuilder.new(klass)
+      end
+
+      def call
+        logicals.each_with_index { |step, i| step.is_a?(Failure) ? link_failure(step, i) : link_step(step, i) }
+        logicals.first
+      end
+
+      private
+
+      def logicals
+        @logicals ||= @steps.map { |step| @step_builder.call(**step) }
+      end
+
+      def link_step(step, index)
+        next_step = logicals[index.next..-1].detect { |next_node| !next_node.is_a?(Failure) }
+        step.add_next_step(step.on_success ? find_step(step.on_success) : next_step)
+        step.add_failure(next_step) if step.is_a?(Pass)
+        step.add_failure(find_step(step.on_failure)) if step.on_failure
+      end
+
+      def link_failure(failure, index)
+        link_previous_steps(failure, index)
+        failure.add_next_step(find_step(failure.on_success)) if failure.on_success
+        failure.add_failure(find_step(failure.on_failure)) if failure.on_failure
+      end
+
+      def link_previous_steps(failure, index)
+        logicals[0...index].reverse_each do |previous_step|
+          previous_step.add_failure(failure) unless previous_step.on_failure || previous_step.is_a?(Pass)
+          next unless previous_step.is_a?(Failure)
+
+          previous_step.add_next_step(failure) unless previous_step.on_success
+          break
+        end
+      end
+
+      def find_step(name)
+        @steps_by_name ||= logicals.group_by(&:name).transform_values(&:first)
+        @steps_by_name[name] || raise(StepIsNotImplementedError.new(@klass, name))
+      end
+    end
+  end
+end

data/lib/yaso/logic/failure.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Failure < Base
+      def call(context, instance)
+        context.success = false
+        @invokable.call(context, instance) ? @next_step : @failure
+      end
+    end
+  end
+end

data/lib/yaso/logic/pass.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Pass < Base
+      def call(context, instance)
+        context.success = true
+        @invokable.call(context, instance) ? @next_step : @failure
+      end
+    end
+  end
+end

data/lib/yaso/logic/step.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Step < Base
+      def call(context, instance)
+        context.success = true
+        if @invokable.call(context, instance)
+          @next_step
+        else
+          context.success = false
+          @failure
+        end
+      end
+    end
+  end
+end

data/lib/yaso/logic/step_builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class StepBuilder
+      CATEGORIES = {
+        step: Step,
+        pass: Pass,
+        failure: Failure,
+        wrap: Wrap,
+        switch: Switch
+      }.freeze
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def call(object:, category:, block:, **opts)
+        invokable_type, invokable = Invokable.call(object, **opts)
+        logic_class = CATEGORIES[category]
+        if invokable_type == Invokable::METHOD
+          opts[:name] = logic_class == Switch ? build_switch(object, **opts, &block) : build_method(object, &block)
+        end
+        opts[:wrapper] = build_wrapper(&block) if logic_class == Wrap
+        logic_class.new(invokable: invokable, **opts)
+      end
+
+      private
+
+      def build_switch(object, options:, **, &block)
+        if block.nil?
+          key = options[:key]
+          cases = options[:cases]
+          block = ->(ctx, **) { cases[ctx[key]] }
+        end
+        build_method(object, &block)
+      end
+
+      def build_method(name, &block)
+        return name if @klass.method_defined?(name) || @klass.private_method_defined?(name)
+        raise StepIsNotImplementedError.new(@klass, name) unless block
+
+        @klass.define_method(name, &block)
+        @klass.instance_eval { private name }
+      end
+
+      def build_wrapper(&block)
+        wrapper_class = Class.new { extend Stepable }
+        wrapper_class.instance_exec(&block)
+        build_wrapper_call(wrapper_class, @klass)
+        wrapper_class
+      end
+
+      def build_wrapper_call(wrapper_class, service_class)
+        wrapper_class.define_singleton_method(:call) do |context, instance|
+          unless @entry
+            @entry = Logic::Classic.call(service_class, steps)
+            clear_steps!
+          end
+          step = @entry
+          step = step.call(context, instance) while step
+          context
+        end
+      end
+    end
+  end
+end

data/lib/yaso/logic/switch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Switch < Base
+      def call(context, instance)
+        context.success = true
+        switch_case = @invokable.call(context, instance) || raise(UnhandledSwitchCaseError, instance.class)
+
+        if Invokable.call(switch_case).last.call(context, instance)
+          @next_step
+        else
+          context.success = false
+          @failure
+        end
+      end
+    end
+  end
+end

data/lib/yaso/logic/wrap.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Logic
+    class Wrap < Base
+      def initialize(wrapper:, **options)
+        super(**options)
+        @wrapper = wrapper
+      end
+
+      def call(context, instance)
+        context.success = true
+        if @invokable.call(context, instance) { @wrapper.call(context, instance).success? }
+          @next_step
+        else
+          context.success = false
+          @failure
+        end
+      end
+    end
+  end
+end

data/lib/yaso/logic.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'logic/base'
+require_relative 'logic/step'
+require_relative 'logic/pass'
+require_relative 'logic/failure'
+require_relative 'logic/wrap'
+require_relative 'logic/switch'
+require_relative 'logic/step_builder'
+require_relative 'logic/classic'
+
+module Yaso
+  module Logic; end
+end

data/lib/yaso/service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Yaso
+  class Service
+    extend Stepable
+
+    def self.call(context = {})
+      context = context.is_a?(Context) ? context : Context.new(context)
+      unless @entry
+        @entry = Logic::Classic.call(self, steps)
+        clear_steps!
+      end
+      step = @entry
+      instance = new
+      step = step.call(context, instance) while step
+      context
+    end
+  end
+end

data/lib/yaso/stepable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Yaso
+  module Stepable
+    def steps
+      @steps ||= []
+    end
+
+    def clear_steps!
+      remove_instance_variable(:@steps)
+    end
+
+    %i[step pass failure wrap switch].each do |category|
+      define_method(category) do |object, options = {}, &block|
+        raise InvalidFirstStepError, category if category == :failure && steps.empty?
+
+        steps << {
+          object: object, category: category, fast: options.delete(:fast), on_success: options.delete(:on_success),
+          on_failure: options.delete(:on_failure), options: options, block: block, name: options.delete(:name)
+        }
+      end
+    end
+  end
+end

data/lib/yaso/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yaso
+  VERSION = '1.0.0pre'
+end

data/lib/yaso.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'yaso/version'
+require_relative 'yaso/errors'
+require_relative 'yaso/context'
+require_relative 'yaso/invokable'
+require_relative 'yaso/stepable'
+require_relative 'yaso/logic'
+require_relative 'yaso/service'
+
+module Yaso; end