NxtPipeline

gem 'nxt_pipeline'

class Validator
  attr_accessor :error
end

class TypeChecker < Validator
  def initialize(value, type:)
    @value = value
    @type = type
  end

  attr_reader :value, :type

  def call
    return if value.is_a?(type)
    self.error = "Value does not match type #{type}"
  end
end

class MinSize < Validator
  def initialize(value, size:)
    @value = value
    @size = size
  end

  attr_reader :value, :size

  def call
    return if value.size >= size
    self.error = "Value size must be greater than #{size-1}"
  end
end

class MaxSize < Validator
  def initialize(value, size:)
    @value = value
    @size = size
  end

  attr_reader :value, :size

  def call
    return if value.size <= size
    self.error = "Value size must be less than #{size+1}"
  end
end

class Uniqueness < Validator
  def initialize(value, scope:)
    @value = value
    @scope = scope
  end

  attr_reader :value, :scope

  def call
    return if scope.count { |item| item == value }
    self.error = "Value is not unique in: #{scope}"
  end
end

result = NxtPipeline.call({ value: 'aki', errors: [] }) do |p|
  p.constructor(:validator, default: true) do |acc, step|
    validator = step.argument.new(acc.fetch(:value), **step.options)
    validator.call
    acc[:errors] << validator.error if validator.error.present?

    acc
  end

  p.step TypeChecker, options: { type: String }
  p.step MinSize, options: { size: 4 }
  p.step MaxSize, options: { size: 10 }
  p.step Uniqueness, options: { scope: ['andy', 'aki', 'lütfi', 'rapha'] }
end

result # => { value: 'aki', errors: ['Value size must be greater than 3'] } 

NxtPipeline.constructor(:service) do |acc, step|
  validator = step.argument.new(acc.fetch(:value), **step.options)
  validator.call
  acc[:errors] << validator.error if validator.error.present?

  acc
end

NxtPipeline.new({ value: 'aki', errors: [] }) do |p|
  p.constructor(:validator, default: true) do |acc, step|
    validator = step.argument.new(acc.fetch(:value), **step.options)
    validator.call
    acc[:errors] << validator.error if validator.error.present?

    acc
  end

  p.step TypeChecker, options: { type: String }
  # ...
end

NxtPipeline.new({}) do |p|
  p.constructor(:service) do |acc, step|
    step.service_class.new(acc).call
  end

  p.step :service, service_class: MyServiceClass
  p.step :service, service_class: MyOtherServiceClass
  # ...
end

# explicitly define which constructor to use 
pipeline.step MyServiceClass, constructor: :service
# use a block as inline constructor
pipeline.step SpecialService, constructor: ->(step, arg:) { step.argument.call(arg: arg) }
# Rely on the default constructor
pipeline.step MyOtherServiceClass
# Define a step name
pipeline.step MyOtherServiceClass, to_s: 'First Step'
# Or simply execute a (named) block - NO NEED TO DEFINE A CONSTRUCTOR HERE  
pipeline.step :step_name_for_better_log do |acc, step|
  # ...
end

pipeline.steps([
  [MyServiceClass, constructor: :service],
  [MyOtherServiceClass, constructor: :service],
  [MyJobClass, constructor: :job]
])

# You can also overwrite the steps of a pipeline through explicitly setting them. This will remove any previously 
# defined steps.
pipeline.steps = [
  [MyServiceClass, constructor: :service],
  [MyOtherServiceClass, constructor: :service]
]

pipeline.call(arg: 'initial argument')

# Or directly pass the steps you want to execute:
pipeline.call(arg: 'initial argument') do |p|
  p.step MyServiceClass, to_s: 'First step'
  p.step MyOtherServiceClass, to_s: 'Second step'
  p.step MyJobClass, constructor: :job
  p.step MyOtherJobClass, constructor: :job
end

NxtPipeline.call(arg: 'initial argument') do |p|
  p.steps # ...
end

pipeline.call('initial argument') do |p|
 p.step MyServiceClass, if: -> (acc, step) { acc == 'initial argument' }
 p.step MyOtherServiceClass, unless: -> { false }
end

NxtPipeline.new do |p|
  p.step # ... 

  p.on_error MyCustomError do |error|
    # First matching error callback will be executed!
  end

  p.on_errors ArgumentError, KeyError do |error, acc|
    # First matching error callback will be executed!
  end

  p.on_errors YetAnotherError, halt_on_error: false do |error, acc, step|
    # After executing the callback the pipeline will not halt but continue to
    # execute the next steps.
  end

  p.on_errors do |error, acc, step|
    # This will match all errors inheriting from StandardError
  end
end

NxtPipeline.new do |p|
  p.before_step do |_, change_set|
    change_set[:acc] << 'before step 1'
    change_set
  end

  p.around_step do |_, change_set, execution|
    change_set[:acc] << 'around step 1'
    execution.call # you have to specify where in your callback you want to call the inner block
    change_set[:acc] << 'around step 1'
    change_set
  end

  p.after_step do |_, change_set|
    change_set[:acc] << 'after step 1'
    change_set
  end
end

NxtPipeline.new do |p|
  p.before_execution do |_, change_set|
    change_set[:acc] << 'before execution 1'
    change_set
  end

  p.around_execution do |_, change_set, execution|
    change_set[:acc] << 'around execution 1'
    execution.call # you have to specify where in your callback you want to call the inner block
    change_set[:acc] << 'around execution 1'
    change_set
  end

  p.after_execution do |_, change_set|
    change_set[:acc] << 'after execution 1'
    change_set
  end
end

class Transform
  def initialize(word, operation)
    @word = word
    @operation = operation
  end

  attr_reader :word, :operation

  def call
    word.send(operation)
  end
end

NxtPipeline.new do |pipeline|
  # dynamically resolve to use a proc as constructor
  pipeline.constructor_resolver do |argument, **opts|
    argument.is_a?(Class) &&
      ->(step, arg:) {
        result = step.argument.new(arg, opts.fetch(:operation)).call
        # OR result = step.argument.new(arg, step.operation).call
        { arg: result }
      }
  end

  # dynamically resolve to a defined constructor
  pipeline.constructor_resolver do |argument|
    argument.is_a?(String) && :dynamic
  end

  pipeline.constructor(:dynamic) do |step, arg:|
    if step.argument == 'multiply'
      { arg: arg * step.multiplier }
    elsif step.argument == 'symbolize'
      { arg: arg.to_sym }
    else
      raise ArgumentError, "Don't know how to deal with argument: #{step.argument}"
    end
  end

  pipeline.step Transform, operation: 'upcase'
  pipeline.step 'multiply', multiplier: 2
  pipeline.step 'symbolize'
  pipeline.step :extract_value do |arg|
    arg
  end
end

# Define configurations in your initializer or somewhere upfront 
NxtPipeline.configuration(:test_processor) do |pipeline|
  pipeline.constructor(:processor) do |arg, step|
    { arg: step.argument.call(arg: arg) }
  end
end

NxtPipeline.configure(:validator) do |pipeline|
  pipeline.constructor(:validator) do |arg, step|
    # ..
  end
end

# ...

# Later create a pipeline with a previously defined configuration
NxtPipeline.new(configuration: :test_processor) do |p|
  p.step ->(arg) { arg + 'first ' }, constructor: :processor
  p.step ->(arg) { arg + 'second ' }, constructor: :processor
  p.step ->(arg) { arg + 'third' }, constructor: :processor
end

pipeline = NxtPipeline.new do |pipeline|
  pipeline.constructor(:step, default: true) do |acc, step|
    result = step.proc.call(acc)
    step.status = result.present? # Set the status here
    step.meta_data = 'additional info' # or some meta data
    acc
  end

  pipeline.step :first_step do |acc, step|
    step.status = 'it worked'
    step.meta_data = { extra: 'info' }
    acc
  end

  pipeline.step :second, proc: ->(acc) { acc }
end

pipeline.logger.log # => { "first_step" => 'it worked', "second" => true } 
pipeline.steps.map(&:meta_data) # => [{:extra=>"info"}, "additional info"]