active_interaction-extras 1.0.4 → 2.0.0

data/lib/active_interaction/extras/append_inputs.rb

@@ -0,0 +1,60 @@
+module ActiveInteraction::Extras::AppendInputs
+  extend ActiveSupport::Concern
+
+  module InputsRefinement
+    refine ActiveInteraction::Inputs do
+      # Based on ActiveInteraction::Inputs#initialize
+      def append(raw_inputs, overwrite: false)
+        new_normalized_inputs = normalize(raw_inputs)
+
+        keys = new_normalized_inputs.keys.map(&:to_sym)
+        keys = keys.reject { given?(_1) } if !overwrite
+
+        new_inputs = @base.class.filters
+          .slice(*keys)
+          .each_with_object({}) do |(name, filter), inputs|
+          inputs[name] = filter.process(new_normalized_inputs[name], @base)
+
+          yield(name, inputs[name]) if block_given?
+        end
+
+        @normalized_inputs = @normalized_inputs.merge(new_normalized_inputs)
+        @inputs = @inputs.merge(new_inputs)
+        @to_h = nil
+      end
+    end
+  end
+
+  using InputsRefinement
+
+  def default_inputs(*args)
+    inputs.append(*args) do |name, input|
+      public_send("#{name}=", input.value)
+    end
+  end
+
+  # def default_input(name, &block)
+  #   if !inputs.given?(name)
+  #     default_inputs(name: block.call)
+  #   end
+  # end
+
+  class_methods do
+    def default_inputs(&block)
+      # prepend: true - so it runs after ActiveInteraction::Extras::ModelFields.assign_model_values_to_filters
+      # callback order is inverse, so that's why it's confusing
+      after_initialize prepend: true do
+        hash = block.call
+        default_inputs(hash)
+      end
+    end
+
+    def default_input(name, &block)
+      # prepend: true - so it runs after ActiveInteraction::Extras::ModelFields.assign_model_values_to_filters
+      # callback order is inverse, so that's why it's confusing
+      after_initialize prepend: true do
+        default_inputs(name => instance_exec(&block))
+      end
+    end
+  end
+end

data/lib/active_interaction/extras/current.rb

@@ -0,0 +1,23 @@
+module ActiveInteraction::Extras::Current
+  extend ActiveSupport::Concern
+
+  class CurrentContext < ActiveSupport::CurrentAttributes
+    attribute :job
+    attribute :batch_event
+    attribute :batch
+
+    def batch
+      super || job&.batch
+    end
+  end
+
+  def current
+    self.class.current
+  end
+
+  class_methods do
+    def current
+      CurrentContext
+    end
+  end
+end

data/lib/active_interaction/extras/file_blobs.rb

@@ -0,0 +1,80 @@
+module ActiveInteraction::Extras::FileBlobs
+  extend ActiveSupport::Concern
+
+  # Returns the blobs for a given array field.
+  #
+  # @example has_one_attached :file
+  #
+  #   # doc/_form.html.slim
+  #   = f.hidden_field :file, value: nil
+  #
+  #   - form.blobs_for(:file).each do |blob|
+  #     div data-controller="remove"
+  #       = f.hidden_field :file, value: blob.signed_id
+  #       - if blob.representable?
+  #         = image_tag url_for(blob.representation(resize_to_fit: [300, 80])), height: 80
+  #       button type="button" data-action="click->remove#remove"
+  #         'Remove
+  #
+  #   = f.input :new_file, as: :file
+  #
+  #   # doc/form.rb
+  #   class Doc::Form < ActiveInteraction::Base
+  #     object :doc
+  #
+  #     model_fields(:doc) do
+  #       anything :file
+  #     end
+  #
+  #     anything :new_file, permit: true, default: nil
+  #
+  #     def execute
+  #       save_model!(:doc)
+  #
+  #       if inputs.given?(:new_file)
+  #         doc.file = new_file
+  #         doc.save!
+  #       end
+  #     end
+  #   end
+  #
+  # @example has_many_attached :files
+  #
+  #   # doc/_form.html.slim
+  #   = f.file_field :files, multiple: true, direct_upload: true
+  #
+  #   # doc/form.rb
+  #   class Doc::Form < ActiveInteraction::Base
+  #     object :doc
+  #
+  #     model_fields(:doc) do
+  #       array :files
+  #     end
+  #
+  #     def execute
+  #       save_model!(:files)
+  #     end
+  #   end
+  #
+  def blobs_for(array_field)
+    # If there is a new upload field, prioritize it
+    new_upload = "new_#{array_field}"
+    if respond_to?(new_upload) && public_send(new_upload).present?
+      array_field = new_upload
+    end
+
+    list = public_send(array_field)
+    list = Array.wrap(list)
+
+    list.compact_blank.map do |file|
+      case file
+      when ActiveStorage::Blob
+        file
+      when ActiveStorage::Attachment, ActiveStorage::Attached::One
+        file.blob
+      when String
+        ActiveStorage::Blob.find_signed(file)
+      end
+    end.compact
+  end
+end

data/lib/active_interaction/extras/filter_alias.rb

@@ -1,16 +1,42 @@
 # frozen_string_literal: true
 
 # Add :as option, which is a read alias to filter
-#   hash :params, as: :account_attributes
+#   hash :account, as: :account_attributes
 #
 module ActiveInteraction::Extras::FilterAlias
   extend ActiveSupport::Concern
 
+  # concern :InputsExtension do
+  #   def normalize(inputs)
+  #     @base.class.filters.each do |name, filter|
+  #       alias_name = filter.options[:as]
+  #
+  #       if alias_name.nil?
+  #         next
+  #
+  #       elsif inputs.key?(alias_name.to_sym)
+  #         inputs[name.to_sym] = inputs[alias_name.to_sym]
+  #
+  #       elsif inputs.key?(alias_name.to_s)
+  #         inputs[name.to_s] = inputs[alias_name.to_s]
+  #       end
+  #     end
+  #
+  #     super
+  #   end
+  # end
+  #
+  # included do
+  #   ActiveInteraction::Inputs.prepend InputsExtension
+  # end
+
   class_methods do
     def initialize_filter(filter)
       super.tap do
         if filter.options[:as]
-          alias_method filter.options[:as], filter.name
+          name = filter.options[:as]
+          alias_method name, filter.name
+          # alias_method "#{name}=", "#{filter.name}="
         end
       end
     end

data/lib/active_interaction/extras/filter_extensions/object_classes.rb

@@ -29,6 +29,8 @@ module ActiveInteraction::Extras::FilterExtensions::ObjectClasses
 
   def matches?(value)
     if polymorphic?
+      return false if value == nil
+
       class_list.any? { |klass| value.class <= klass }
     else
       super

data/lib/active_interaction/extras/filter_extensions.rb

@@ -1,2 +1,10 @@
+module ActiveInteraction
+  module Extras
+    module FilterExtensions
+
+    end
+  end
+end
+
 require 'active_interaction/extras/filter_extensions/hash_auto_strip'
 require 'active_interaction/extras/filter_extensions/object_classes'

data/lib/active_interaction/extras/filters/anything_filter.rb

@@ -3,7 +3,14 @@
 class ActiveInteraction::Extras::Filters::AnythingFilter < ActiveInteraction::Filter
   register :anything
 
-  def matches?(_object)
-    true
+  def matches?(value)
+    if value == nil && default?
+      # as per v5 there is no way to know if value of `nil` is given by caller or
+      # is a default value when it's missing. We want to maintain standard default
+      # behaviour when value is `nil`. Returning `false` will trigger default value
+      false
+    else
+      true
+    end
   end
 end

data/lib/active_interaction/extras/filters/ar_relation_filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class ActiveInteraction::Extras::Filters::ArRelationFilter < ActiveInteraction::ObjectFilter
+  register :ar_relation
+
+  def initialize(...)
+    super
+    @options.reverse_merge!(class: ActiveRecord::Relation)
+  end
+
+  def matches?(value)
+    # value == nil triggers active record loading
+    if value.nil? && default?
+      # as per v5 there is no way to know if value of `nil` is given by caller or
+      # is a default value when it's missing. We want to maintain standard default
+      # behaviour when value is `nil`. Returning `false` will trigger default value
+      false
+    else
+      true
+    end
+  end
+end

data/lib/active_interaction/extras/filters/uuid_filter.rb

@@ -3,13 +3,18 @@
 class ActiveInteraction::Extras::Filters::UUIDFilter < ActiveInteraction::StringFilter
   register :uuid
 
-  REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.freeze
+  REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[457][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.freeze
 
   def matches?(value)
     super && REGEX.match?(value)
   end
 
   def convert(value)
-    super&.presence
+    value, error = super
+    if error
+      [value, error]
+    else
+      [value&.presence, nil]
+    end
   end
 end

data/lib/active_interaction/extras/form_for.rb

@@ -0,0 +1,33 @@
+module ActiveInteraction::Extras::FormFor
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Changes route key so url helpers work
+    #
+    # @example
+    #   class User::Form < ActiveInteraction::Base
+    #     object :user
+    #     form_for :user
+    #   end
+    #
+    #   url_for(form) #=> "/users/1"
+    def form_for(field_name)
+      delegate :persisted?, :id, :to_param, to: field_name
+
+      if filters.key?(field_name)
+        klass = filters.fetch(field_name).send(:klass)
+        model_name.route_key = klass.model_name.route_key
+        model_name.singular_route_key = klass.model_name.singular_route_key
+      end
+
+      # TODO: Routes reload is broken in Dev
+      # Resolve form object route to object
+      # e.g. resolve "User::Form" { |form| form.user }
+      # Rails.application.config.after_routes_loaded do |app|
+      #   app.routes.add_polymorphic_mapping(name, {}) do |form|
+      #     form.send(field_name)
+      #   end
+      # end
+    end
+  end
+end

data/lib/active_interaction/extras/good_job.rb

@@ -0,0 +1,45 @@
+require 'active_job'
+
+module ActiveInteraction::Extras::GoodJob
+  extend ActiveSupport::Concern
+  include ActiveInteraction::Extras::ActiveJob
+
+  module BatchJobPerform
+    def perform(batch, options)
+      ActiveInteraction::Extras::Current::CurrentContext
+        .set(batch:, batch_event: options[:event]) do
+        super(batch.properties)
+      end
+    end
+  end
+
+  # Note: Should include GoodJob::ActiveJobExtensions::Concurrency before this
+  module Perform
+    extend ActiveSupport::Concern
+    include ActiveInteraction::Extras::ActiveJob::Perform
+
+    def _good_job_default_concurrency_key
+      Digest::MD5.base64digest([self.class.name, arguments].to_param)
+    end
+  end
+
+  class_methods do
+    def define_job_class(klass)
+      super
+
+      unless const_defined?(:BatchJob, false)
+        const_set(:BatchJob, Class.new(job_class) do
+          include BatchJobPerform
+        end)
+      end
+    end
+
+    def batch_job(job_params)
+      batch = GoodJob::Batch.new
+      batch.description = self.name
+      batch.on_finish = self::BatchJob.name
+      batch.properties = job_params
+      batch
+    end
+  end
+end

data/lib/active_interaction/extras/include_errors.rb

@@ -0,0 +1,10 @@
+module ActiveInteraction::Extras::IncludeErrors
+  extend ActiveSupport::Concern
+
+  include ActiveInteraction::Extras::Halt
+
+  def include_errors!(model, **mapping)
+    errors.merge! model.errors, **mapping
+    halt_if_errors!
+  end
+end

data/lib/active_interaction/extras/initialize_with.rb

@@ -0,0 +1,16 @@
+module ActiveInteraction::Extras::InitializeWith
+  extend ActiveSupport::Concern
+
+  include ActiveInteraction::Extras::AfterInitialize
+
+  class_methods do
+    def initialize_with(&block)
+      after_initialize do
+        hash = instance_exec(&block)
+        hash&.each do |filter_name, value|
+          public_send "#{filter_name}=", value if !inputs.given?(filter_name)
+        end
+      end
+    end
+  end
+end

data/lib/active_interaction/extras/instance_runnable.rb

@@ -0,0 +1,35 @@
+# Allows Interaction.new.run
+# Useful for controllers, so single object could be instantiated for new, create, edit, update
+# @example
+#   def form
+#     @form ||= Form.new(record:, params:)
+#   end
+#
+#   def create
+#     if form.save
+#       ...
+#     else
+#       ...
+#     end
+#   end
+#
+module ActiveInteraction::Extras::InstanceRunnable
+  extend ActiveSupport::Concern
+
+  def save
+    run
+    valid?
+  end
+
+  def save!
+    run!
+  end
+
+  def run
+    if @_executed
+      raise("Service already executed")
+    end
+    @_executed = true
+    super
+  end
+end

data/lib/active_interaction/extras/model_fields.rb

@@ -2,36 +2,17 @@ require "active_support/core_ext/object/with_options"
 
 module ActiveInteraction::Extras::ModelFields
   extend ActiveSupport::Concern
-
-  # returns hash of all model fields and their values
-  def model_fields(model_name)
-    fields = self.class.model_field_cache[model_name]
-    inputs.slice(*fields)
-  end
-
-  # returns hash of only changed model fields and their values
-  def changed_model_fields(model_name)
-    model_fields(model_name).select do |field, _value|
-      any_changed?(field)
-    end
-  end
-
-  # returns hash of only given model fields and their values
-  def given_model_fields(model_name)
-    model_fields(model_name).select do |field, _value|
-      given?(field)
-    end
-  end
+  include ActiveInteraction::Extras::AfterInitialize
 
   class Context < SimpleDelegator
     attr_accessor :from_model_name
     attr_accessor :model_field_cache
 
-    def custom_filter_attribute(name, opts = {})
+    def custom_filter_attribute(name, opts = {}, &block)
       from_model_name = self.from_model_name
       model_field_cache[from_model_name] = model_field_cache[from_model_name] << name
 
-      __getobj__.send __callee__, name, opts
+      __getobj__.send __callee__, name, opts, &block
     end
 
     alias interface custom_filter_attribute
@@ -54,33 +35,90 @@ module ActiveInteraction::Extras::ModelFields
     alias uuid custom_filter_attribute
   end
 
+  included do
+    after_initialize :assign_model_values_to_filters
+  end
+
+  # returns hash of all model fields and their values
+  def model_fields(model_name)
+    fields = self.class.model_field_cache[model_name]
+    fields.to_h do |field|
+      [field, public_send(field)]
+    end
+  end
+
+  # returns hash of only changed model fields and their values
+  def changed_model_fields(model_name)
+    model_fields(model_name).select do |field, _value|
+      any_changed?(field)
+    end
+  end
+
+  def assign_model_fields(model_name)
+    model = public_send(model_name)
+    model.assign_attributes(model_fields(model_name))
+    model
+  end
+
+  def save_model!(model_name)
+    model = assign_model_fields(model_name)
+    model.save
+    include_errors! model
+    model
+  end
+
+  def assign_model_changes(model_name)
+    model = public_send(model_name)
+    model.assign_attributes(changed_model_fields(model_name))
+    model
+  end
+
+  def save_model_changes!(model_name)
+    model = assign_model_changes(model_name)
+    model.save
+    include_errors! model
+    model
+  end
+
+  # returns hash of only given model fields and their values
+  def given_model_fields(model_name)
+    model_fields(model_name).select do |field, _value|
+      inputs.given?(field)
+    end
+  end
+
   # checks if value was given to the service and the value is different from
   # the one on the model
   def any_changed?(*fields)
     fields.any? do |field|
       model_field = self.class.model_field_cache_inverse[field]
-      value_changed = true
-
       if model_field
-        value_changed = send(model_field).send(field) != send(field)
+        model = send(model_field)
+        if model.respond_to?(:new_record?) && model.new_record?
+          true
+        elsif inputs.given?(field)
+          # NOTE: this causes bug when form attribute was manually changed, but `inputs.given?` is false
+          # change won't be detected
+          model.send(field) != send(field)
+        else
+          false
+        end
+      else
+        inputs.given?(field)
       end
-
-      given?(field) && value_changed
     end
   end
 
-  # overwritten to pre-populate model fields
-  def populate_filters_and_inputs(_inputs)
-    super.tap do
-      self.class.filters.each do |name, filter|
-        next if given?(name)
+  def assign_model_values_to_filters
+    self.class.filters.each do |name, filter|
+      next if inputs.given?(name)
 
-        model_field = self.class.model_field_cache_inverse[name]
-        next if model_field.nil?
+      model_field = self.class.model_field_cache_inverse[name]
+      next if model_field.nil?
 
-        value = public_send(model_field)&.public_send(name)
-        public_send("#{name}=", filter.clean(value, self))
-      end
+      value = public_send(model_field)&.public_send(name)
+      input = filter.process(value, self)
+      public_send("#{name}=", input.value)
     end
   end
 

data/lib/active_interaction/extras/model_names.rb

@@ -0,0 +1,20 @@
+module ActiveInteraction::Extras::ModelNames
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def inherited(subclass)
+      super.tap { subclass.set_model_naming }
+    end
+
+    def set_model_naming
+      str = name.deconstantize.underscore
+      model_name.route_key = str.pluralize.to_sym
+      model_name.singular_route_key = str.singularize.to_sym
+    end
+
+    def singular_resource_route_key!
+      str = name.deconstantize.underscore
+      model_name.route_key = str.singularize.to_sym
+    end
+  end
+end

data/lib/active_interaction/extras/named_callbacks.rb

@@ -0,0 +1,54 @@
+module ActiveInteraction::Extras::NamedCallbacks
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def before_filter(...)
+      set_callback(:filter, :before, ...)
+    end
+
+    def after_filter(...)
+      set_callback(:filter, :after, ...)
+    end
+
+    def around_filter(...)
+      set_callback(:filter, :around, ...)
+    end
+
+
+    def before_validate(...)
+      set_callback(:validate, :before, ...)
+    end
+
+    def after_validate(...)
+      set_callback(:validate, :after, ...)
+    end
+
+    def around_validate(...)
+      set_callback(:validate, :around, ...)
+    end
+
+    def before_validation(...)
+      before_validate(...)
+    end
+
+    def after_validation(...)
+      after_validate(...)
+    end
+
+    def around_validation(...)
+      around_validate(...)
+    end
+
+    def before_execute(...)
+      set_callback(:execute, :before, ...)
+    end
+
+    def after_execute(...)
+      set_callback(:execute, :after, ...)
+    end
+
+    def around_execute(...)
+      set_callback(:execute, :around, ...)
+    end
+  end
+end