praxis 2.0.pre.19 → 2.0.pre.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58ae0c1f92272e7fd0aaaa779fb679db4b14f6e8d2f9df08efaec211bd3cc4f0
-  data.tar.gz: 19b73ba6239911b4b0f6d3097e58671f556f7835514b7fa52269c1a81f47d837
+  metadata.gz: fcf3359dc0ac9062c61efc934673d9bf5dfdda43e5abfbc9abc41d3030a7a00e
+  data.tar.gz: 04ffe07b27222f714b8da5e756cc9e1733b76d066a9e1bf5a3d15358dc7e6662
 SHA512:
-  metadata.gz: f488d80d4e1495b3574bce59a20826c418ac663d6417838a24f7ef92770e73dd789fe3b9d432a5663b4e6cd5abe665be5d4fc96919c20d93dac0cd981732b4ec
-  data.tar.gz: b8ffc24d28567d4b00a83c8b03bfd00539791af3a675ec315858a800d9e7890bf5bbcb1b811cd91ef8a13c9edc10be96eefb605e34139c789b5ec174b6975342
+  metadata.gz: f90af4ae85f4170a850d7d7637758c0c2d878271befa2fe437da8c994ac78657eebd28831bb0945a74ca48aa93a91d42e8b734fd70f3996984e427ad6850a7ae
+  data.tar.gz: b8eaa60ce2ba599b94f4b844339df8501ca295f3e1efb9a0f5dd38b9c4551aa64f108ba3a28913d06a22748dab11fee5c4bd8f9cfb8d2e85b1c456fb3284a5b3

data/.travis.yml

@@ -3,7 +3,7 @@ language: ruby
 rvm:
   - 2.6
   - 2.7
-  # - 3.1 # Not available in TravisCI out of the box yet
+  - 3.1 # Not available in TravisCI out of the box yet
 script:
   - bundle exec rspec spec
 branches:

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## next
 
+## 2.0.pre.22
+  * Introduced Resource callbacks (an includeable concern). Callbacks allow you to define methods or blocks to be executed `before`, `after` or `around` any existing method in the resource. Class-level callbacks are defined with `self.xxxxx`. These methods will be executed within the instance of the resource (i.e., in the same context of the original) and must be defined with the same parameter signature. For around methods, only blocks can be used, and to call the original (inner) one, one needs to yield.
+  * Introduced QueryMethods for resources (an includeable concern). QueryMethods expose handy querying methods (`.get`, `.get!`, `.all`, `.first` and `.last` ) which will reach into the underlying ORM (i.e., right now, only ActiveModelCompat is supported) to perform the desired loading of data (and subsequent wrapping of results in resource instances).
+    * For ActiveRecord `.get` takes a condition hash that will translate to `.find_by`, and `.all` gets a condition hash that will translate to `.where`. 
+    * `.get!` is a `.get` but that will raise a `Praxis::Mapper::ResourceNotFound` exception if nothing was found.
+    * There is an `.including(<spec>)` function that can be use to preload the underlying associations. I.e., the `<spec>` argument will translate to `.includes(<spec>)` in ActiveRecord.
+  * Introduced method signatures and validations for resources.
+    * One can define a method signature with the `signature(<name>)` stanza, passing a block defining Attributor parameters. For instance method signatures, the `<name>` is just a symbol with the name of the method. For class level methods use a string, and prepend `self.` to it (i.e., `self.create`).
+    * Signatures can only work for methods that either have a single argument (taken as a whole hash), or that have only keyword arguments (i.e., no mixed args and kwargs). It would be basically impossible to validate that combo against an Attributor Struct.
+    * The calls to typed methods will be intercepted (using an around callback), and the incoming parameters will be validated against the Attributor Struct defined in the siguature, coerced if necessary and passed onto the original method. If the incoming parameters fail validation, a `IncompatibleTypeForMethodArguments` exception will be thrown.
+
+## 2.0.pre.21
+  * Fix nullable attribute in OpenApi generation
+## 2.0.pre.20
+* Changed the behavior of dev-mode when validate_responses. Now they return a 500 status code (instead of a 400) but with the same validation error format body.
+  * validate_responses is meant to catch the application returning non-compliant responses for development only. As such, a 500 is much more appropriate and clear, as the validation is done on the behavior of the server, and not on the information sent by the client (i.e., it is a server problem, not reacting the way the API is defined)
+* Introduced a method to reload a Resouce (.reload), which will clear the memoized values and call record.reload as well
+* Open API Generation enhancements:
+  * Fixed type discovery (where some types wouldn't be included in the output)
+  * Changed the generation to output named types into components, and use `$ref` to point to them whenever appropriate
+  * Report nullable attributes
 ## 2.0.pre.19
 * Introduced a new DSL for the `FilteringParams` type that allows filters for common attributes in your Media Types:
   * The new `any` DSL allows you to define which final leaf attribute to always allow, and with which operators and/or fuzzy restrictions.

data/lib/praxis/blueprint.rb

@@ -38,6 +38,7 @@ module Praxis
       end
     end
     include Attributor::Type
+    include Attributor::Container
     include Attributor::Dumpable
 
     extend Finalizable

data/lib/praxis/collection.rb

@@ -37,7 +37,7 @@ module Praxis
       the_type = @attribute&.type || member_type
       {
         type: json_schema_type,
-        items: { '$ref': "#/components/schemas/#{the_type.id}" }
+        items: the_type.as_json_schema
       }
     end
   end

data/lib/praxis/docs/open_api/media_type_object.rb

@@ -27,9 +27,9 @@ module Praxis
           return {} if type.is_a? SimpleMediaType # NOTE: skip if it's a SimpleMediaType?? ... is that correct?
 
           the_schema = if type.anonymous? || !(type < Praxis::MediaType) # Avoid referencing  custom/simple Types? (i.e., just MTs)
-                         SchemaObject.new(info: type).dump_schema
+                         SchemaObject.new(info: type).dump_schema(shallow: false, allow_ref: false)
                        else
-                         { '$ref': "#/components/schemas/#{type.id}" }
+                         SchemaObject.new(info: type).dump_schema(shallow: true, allow_ref: true)
                        end
 
           if example_payload

data/lib/praxis/docs/open_api/operation_object.rb

@@ -23,7 +23,6 @@ module Praxis
           all_tags = tags + action.traits
           h = {
             summary: action.name.to_s,
-            description: action.description,
             # externalDocs: {}, # TODO/FIXME
             operationId: id,
             responses: ResponsesObject.new(responses: action.responses).dump
@@ -32,6 +31,7 @@ module Praxis
             # security: [{}]
             # servers: [{}]
           }
+          h[:description] = action.description if action.description
           h[:tags] = all_tags.uniq unless all_tags.empty?
           h[:parameters] = all_parameters unless all_parameters.empty?
           h[:requestBody] = RequestBodyObject.new(attribute: action.payload).dump if action.payload

data/lib/praxis/docs/open_api/schema_object.rb

@@ -5,33 +5,65 @@ module Praxis
     module OpenApi
       class SchemaObject
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#schema-object
-        attr_reader :type, :attribute
+        attr_reader :type
 
         def initialize(info:)
-          # info could be an attribute ... or a type?
-          if info.is_a? Attributor::Attribute
-            @attribute = info
+          @attribute_options = {}
+
+          # info could be an attribute ... or a type
+          if info.is_a?(Attributor::Attribute)
+            @type = info.type
+            # Save the options that might be attached to the attribute, to add them to the type schema later
+            @attribute_options = info.options
           else
             @type = info
           end
+
+          # Mediatypes have the description method, lower types don't
+          @attribute_options[:description] = @type.description if @type.respond_to?(:description)
+          @collection = type.respond_to?(:member_type)
         end
 
         def dump_example
-          ex = \
-            if attribute
-              attribute.example
-            else
-              type.example
-            end
+          ex = type.example
           ex.respond_to?(:dump) ? ex.dump : ex
         end
 
-        def dump_schema
-          if attribute
-            attribute.as_json_schema(shallow: true, example: nil)
+        def dump_schema(shallow: false, allow_ref: false)
+          # We will dump schemas for mediatypes by simply creating a reference to the components' section
+          if type < Attributor::Container
+            if (type < Praxis::Blueprint || type < Attributor::Model) && allow_ref && !type.anonymous?
+              # TODO: Do we even need a description?
+              h = @attribute_options[:description] ? { 'description' => @attribute_options[:description] } : {}
+
+              Praxis::Docs::OpenApiGenerator.instance.register_seen_component(type)
+              h.merge!('$ref' => "#/components/schemas/#{type.id}")
+            elsif @collection
+              items = OpenApi::SchemaObject.new(info: type.member_type).dump_schema(allow_ref: allow_ref, shallow: false)
+              h = @attribute_options[:description] ? { 'description' => @attribute_options[:description] } : {}
+              h.merge!(type: 'array', items: items)
+            else # Attributor::Struct, etc
+              props = type.attributes.transform_values do |definition|
+                OpenApi::SchemaObject.new(info: definition).dump_schema(allow_ref: true, shallow: shallow)
+              end
+              h = { type: :object, properties: props } # TODO: Example?
+            end
           else
-            type.as_json_schema(shallow: true, example: nil)
+            # OpenApi::SchemaObject.new(info:target).dump_schema(allow_ref: allow_ref, shallow: shallow)
+            # TODO...we need to make sure we can use refs in the underlying components after the first level...
+            # ... maybe we need to loop over the attributes if it's an object/struct?...
+            h = type.as_json_schema(shallow: shallow, example: nil, attribute_options: @attribute_options)
           end
+
+          # Tag on OpenAPI specific requirements that aren't already added in the underlying JSON schema model
+          # Nullable: (it seems we need to ensure there is a null option to the enum, if there is one)
+          if @attribute_options[:null]
+            h[:nullable] = @attribute_options[:null]
+            h[:enum] = h[:enum] + [nil] if h[:enum] && !h[:enum].include?(nil)
+          end
+
+          h
+
           # # TODO: FIXME: return a generic object type if the passed info was weird.
           # return { type: :object } unless info
 

data/lib/praxis/docs/open_api/tag_object.rb

@@ -12,11 +12,11 @@ module Praxis
         end
 
         def dump
-          {
-            name: name,
-            description: description
+          h = description ? { description: description } : {}
+          h.merge(
+            name: name
             # externalDocs: ???,
-          }
+          )
         end
       end
     end

data/lib/praxis/docs/open_api_generator.rb

@@ -9,6 +9,7 @@ module Praxis
   module Docs
     class OpenApiGenerator
       require 'active_support/core_ext/enumerable' # For index_by
+      include Singleton
 
       API_DOCS_DIRNAME = 'docs/openapi'
       EXCLUDED_TYPES_FROM_OUTPUT = Set.new([
@@ -26,7 +27,7 @@ module Praxis
                                              Attributor::URI
                                            ]).freeze
 
-      attr_reader :resources_by_version, :types_by_id, :infos_by_version, :doc_root_dir
+      attr_reader :resources_by_version, :infos_by_version, :doc_root_dir
 
       # substitutes ":params_like_so" for {params_like_so}
       def self.templatize_url(string)
@@ -34,24 +35,37 @@ module Praxis
       end
 
       def save!
+        raise 'You need to configure the root directory before saving (configure_root(<dir>))' unless @root
+
         initialize_directories
         # Restrict the versions listed in the index file to the ones for which we have at least 1 resource
         write_index_file(for_versions: resources_by_version.keys)
         resources_by_version.each_key do |version|
+          @seen_components_for_current_version = Set.new
           write_version_file(version)
         end
       end
 
-      def initialize(root)
+      def initialize
         require 'yaml'
-        @root = root
+
         @resources_by_version = Hash.new do |h, k|
           h[k] = Set.new
         end
-
+        # List of types that we have seen/marked as necessary to list in the components/schemas section
+        # These should contain any mediatype define in the versioned controllers plus any type
+        # for which we've explicitly rendered a $ref schema
+        @seen_components_for_current_version = Set.new
         @infos = ApiDefinition.instance.infos
         collect_resources
-        collect_types
+      end
+
+      def configure_root(root)
+        @root = root
+      end
+
+      def register_seen_component(type)
+        @seen_components_for_current_version.add(type)
       end
 
       private
@@ -69,63 +83,16 @@ module Praxis
         end
       end
 
-      def collect_types
-        @types_by_id = ObjectSpace.each_object(Class).select do |obj|
-          obj < Attributor::Type
-        end.index_by(&:id)
-      end
-
       def write_index_file(for_versions:)
         # TODO. create a simple html file that can link to the individual versions available
       end
 
-      def scan_types_for_version(version, dumped_resources)
-        found_media_types = resources_by_version[version].select(&:media_type).collect { |r| r.media_type.describe }
-
+      # TODO: Change this function name to scan_default_mediatypes...
+      def collect_default_mediatypes(endpoints)
         # We'll start by processing the rendered mediatypes
-        processed_types = Set.new(resources_by_version[version].select do |r|
-          r.media_type && !r.media_type.is_a?(Praxis::SimpleMediaType)
+        Set.new(endpoints.select do |endpoint|
+          endpoint.media_type && !endpoint.media_type.is_a?(Praxis::SimpleMediaType)
         end.collect(&:media_type))
-
-        newfound = Set.new
-        found_media_types.each do |mt|
-          newfound += scan_dump_for_types({ type: mt }, processed_types)
-        end
-        # Then will process the rendered resources (noting)
-        newfound += scan_dump_for_types(dumped_resources, Set.new)
-
-        # At this point we've done a scan of the dumped resources and mediatypes.
-        # In that scan we've discovered a bunch of types, however, many of those might have appeared in the JSON
-        # rendered in just shallow mode, so it is not guaranteed that we've seen all the available types.
-        # For that we'll do a (non-shallow) dump of all the types we found, and scan them until the scans do not
-        # yield types we haven't seen before
-        until newfound.empty?
-          dumped = newfound.collect(&:describe)
-          processed_types += newfound
-          newfound = scan_dump_for_types(dumped, processed_types)
-        end
-        processed_types
-      end
-
-      def scan_dump_for_types(data, processed_types)
-        newfound_types = Set.new
-        case data
-        when Array
-          data.collect { |item| newfound_types += scan_dump_for_types(item, processed_types) }
-        when Hash
-          if data.key?(:type) && data[:type].is_a?(Hash) && (%i[id name family] - data[:type].keys).empty?
-            type_id = data[:type][:id]
-            unless type_id.nil? || type_id == Praxis::SimpleMediaType.id # SimpleTypes shouldn't be collected
-              unless types_by_id[type_id]
-                raise "Error! We have detected a reference to a 'Type' with id='#{type_id}' which is not derived from Attributor::Type" \
-                      ' Document generation cannot proceed.'
-              end
-              newfound_types << types_by_id[type_id] unless processed_types.include? types_by_id[type_id]
-            end
-          end
-          data.values.map { |item| newfound_types += scan_dump_for_types(item, processed_types) }
-        end
-        newfound_types
       end
 
       def write_version_file(version)
@@ -133,11 +100,11 @@ module Praxis
         # # Hack, let's "inherit/copy" all traits of a version from the global definition
         # # Eventually traits should be defined for a version (and inheritable from global) so we'll emulate that here
         # version_info[:traits] = infos_by_version[:traits]
-        dumped_resources = dump_resources(resources_by_version[version])
-        processed_types = scan_types_for_version(version, dumped_resources)
 
+        # We'll for sure include any of the default mediatypes in the endpoints for this version
+        @seen_components_for_current_version.merge(collect_default_mediatypes(resources_by_version[version]))
         # Here we have:
-        # processed types: which includes mediatypes and normal types...real classes
+        # processed types: which includes default mediatypes for the processed endpoints
         # processed resources for this version: resources_by_version[version]
 
         info_object = OpenApi::InfoObject.new(version: version, api_definition_info: @infos[version])
@@ -168,8 +135,8 @@ module Praxis
         end
         full_data[:tags] = full_data[:tags] + tags_for_traits unless tags_for_traits.empty?
 
-        # Include only MTs (i.e., not custom types or simple types...)
-        component_schemas = reusable_schema_objects(processed_types.select { |t| t < Praxis::MediaType })
+        # Include only MTs and Blueprints (i.e., no simple types...)
+        component_schemas = add_component_schemas(@seen_components_for_current_version.clone, {})
 
         # 3- Then adding all of the top level Mediatypes...so we can present them at the bottom, otherwise they don't show
         tags_for_mts = component_schemas.map do |(name, _info)|
@@ -251,16 +218,16 @@ module Praxis
         end
       end
 
-      def reusable_schema_objects(types)
-        types.each_with_object({}) do |(type), accum|
-          the_type = \
-            if type.respond_to? :as_json_schema
-              type
-            else # If it is a blueprint ... for now, it'd be through the attribute
-              type.attribute
-            end
-          accum[type.id] = the_type.as_json_schema(shallow: false)
+      def add_component_schemas(types_to_add, components_hash)
+        initial = @seen_components_for_current_version.dup
+        types_to_add.each_with_object(components_hash) do |(type), accum|
+          # For components, we want the first level to be fully dumped (only references below that)
+          accum[type.id] = OpenApi::SchemaObject.new(info: type).dump_schema(allow_ref: false, shallow: false)
         end
+        newfound = @seen_components_for_current_version - initial
+        # Process the new types if they have discovered
+        add_component_schemas(newfound, components_hash) unless newfound.empty?
+        components_hash
       end
 
       def convert_to_parameter_object(params)

data/lib/praxis/mapper/active_model_compat.rb

@@ -80,6 +80,27 @@ module Praxis
           end
         end
 
+        # Compatible reader accessors
+        def _get(condition)
+          find_by(condition)
+        end
+
+        def _all(conditions = {})
+          where(conditions)
+        end
+
+        def _add_includes(base, includes)
+          base.includes(includes) # includes(nil) seems to have no effect
+        end
+
+        def _first
+          first
+        end
+
+        def _last
+          last
+        end
+
         private
 
         def local_columns_used_for_the_association(type, assoc_reflection)

data/lib/praxis/mapper/resource.rb

@@ -4,6 +4,15 @@
 # Once that is complete, the data set is iterated and a resultant view is generated.
 module Praxis
   module Mapper
+    class ResourceNotFound < RuntimeError
+      attr_reader :type, :id
+
+      def initialize(type:, id: nil)
+        @type = type
+        @id = id
+      end
+    end
+
     class Resource
       extend Praxis::Finalizable
 
@@ -13,6 +22,8 @@ module Praxis
 
       class << self
         attr_reader :model_map, :properties
+        # Names of the memoizable things (without the @__ prefix)
+        attr_accessor :memoized_variables
       end
 
       # TODO: also support an attribute of sorts on the versioned resource module. ie, V1::Resources.api_version.
@@ -32,6 +43,7 @@ module Praxis
 
           @properties = superclass.properties.clone
           @_filters_map = {}
+          @memoized_variables = []
         end
       end
 
@@ -55,6 +67,7 @@ module Praxis
         finalize_resource_delegates
         define_model_accessors
 
+        hookup_callbacks
         super
       end
 
@@ -76,6 +89,39 @@ module Praxis
         end
       end
 
+      def self.hookup_callbacks
+        return unless ancestors.include?(Praxis::Mapper::Resources::Callbacks)
+
+        instance_module = nil
+        class_module = nil
+
+        affected_methods = (before_callbacks.keys + after_callbacks.keys + around_callbacks.keys).uniq
+        affected_methods&.each do |method|
+          calls = {}
+          calls[:before] = before_callbacks[method] if before_callbacks.key?(method)
+          calls[:around] = around_callbacks[method] if around_callbacks.key?(method)
+          calls[:after] = after_callbacks[method] if after_callbacks.key?(method)
+
+          if method.start_with?('self.')
+            # Look for a Class method
+            simple_name = method.to_s.gsub(/^self./, '').to_sym
+            raise "Error building callback: Class-level method #{method} is not defined in class #{name}" unless methods.include?(simple_name)
+
+            class_module ||= Module.new
+            create_override_module(mod: class_module, method: method(simple_name), calls: calls)
+          else
+            # Look for an instance method
+            raise "Error building callback: Instance method #{method} is not defined in class #{name}" unless method_defined?(method)
+
+            instance_module ||= Module.new
+            create_override_module(mod: instance_module, method: instance_method(method), calls: calls)
+          end
+        end
+        # Prepend the created instance and/or class modules if there were any functions in them
+        prepend instance_module if instance_module
+        singleton_class.send(:prepend, class_module) if class_module
+      end
+
       def self.for_record(record)
         return record._resource if record._resource
 
@@ -130,10 +176,13 @@ module Praxis
 
         return unless association_resource_class
 
+        memoized_variables << name
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}
+          return @__#{name} if instance_variable_defined?("@__#{name}")
+
           records = record.#{name}
-            return nil if records.nil?
+          return nil if records.nil?
           @__#{name} ||= #{association_resource_class}.wrap(records)
         end
         RUBY
@@ -151,6 +200,7 @@ module Praxis
       end
 
       def self.define_delegation_for_related_attribute(resource_name, resource_attribute)
+        memoized_variables << resource_attribute
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{resource_attribute}
           @__#{resource_attribute} ||= if (rec = self.#{resource_name})
@@ -164,6 +214,7 @@ module Praxis
         related_resource_class = model_map[related_association[:model]]
         return unless related_resource_class
 
+        memoized_variables << resource_attribute
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{resource_attribute}
           @__#{resource_attribute} ||= if (rec = self.#{resource_name})
@@ -176,15 +227,18 @@ module Praxis
       end
 
       def self.define_accessor(name)
-        ivar_name = if name.to_s =~ /\?/
+        ivar_name = case name.to_s
+                    when /\?/
                       "is_#{name.to_s[0..-2]}"
+                    when /!/
+                      "#{name.to_s[0..-2]}_bang"
                     else
                       name.to_s
                     end
-
+        memoized_variables << ivar_name
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
       def #{name}
-        return @__#{ivar_name} if defined? @__#{ivar_name}
+        return @__#{ivar_name} if instance_variable_defined?("@__#{ivar_name}")
         @__#{ivar_name} = record.#{name}
       end
         RUBY
@@ -239,6 +293,23 @@ module Praxis
         @record = record
       end
 
+      def reload
+        clear_memoization
+        reload_record
+        self
+      end
+
+      def clear_memoization
+        self.class.memoized_variables.each do |name|
+          ivar = "@__#{name}"
+          remove_instance_variable(ivar) if instance_variable_defined?(ivar)
+        end
+      end
+
+      def reload_record
+        record.reload
+      end
+
       def respond_to_missing?(name, *)
         @record.respond_to?(name) || super
       end
@@ -251,6 +322,81 @@ module Praxis
           super
         end
       end
+
+      # Defines a 'proxy' method in the given module (mod), so it can then be prepended
+      # There are mostly 3 flavors, which dictate how to define the procs (to make sure we play nicely
+      # with ruby's arguments and all). Method with only args, with only kwords, and with both
+      # Note: if procs could be defined with the (...) syntax, this could be more DRY and simple...
+      def self.create_override_module(mod:, method:, calls:)
+        has_args = method.parameters.any? { |(type, _)| %i[req opt rest].include?(type) }
+        has_kwargs = method.parameters.any? { |(type, _)| %i[keyreq keyrest].include?(type) }
+
+        mod.class_eval do
+          if has_args && has_kwargs
+            # Setup the method to take both args and  kwargs
+            define_method(method.name.to_sym) do |*args, **kwargs|
+              calls[:before]&.each do |target|
+                target.is_a?(Symbol) ? send(target, *args, **kwargs) : instance_exec(*args, **kwargs, &target)
+              end
+
+              orig_call = proc { |*a, **kw| super(*a, **kw) }
+              around_chain = calls[:around].inject(orig_call) do |inner, target|
+                proc { |*a, **kw| send(target, *a, **kw, &inner) }
+              end
+              result = if calls[:around].presence
+                         around_chain.call(*args, **kwargs)
+                       else
+                         super(*args, **kwargs)
+                       end
+              calls[:after]&.each do |target|
+                target.is_a?(Symbol) ? send(target, *args, **kwargs) : instance_exec(*args, **kwargs, &target)
+              end
+              result
+            end
+          elsif has_kwargs && !has_args
+            # Setup the method to only take kwargs
+            define_method(method.name.to_sym) do |**kwargs|
+              calls[:before]&.each do |target|
+                target.is_a?(Symbol) ? send(target, **kwargs) : instance_exec(**kwargs, &target)
+              end
+              orig_call = proc { |**kw| super(**kw) }
+              around_chain = calls[:around].inject(orig_call) do |inner, target|
+                proc { |**kw| send(target, **kw, &inner) }
+              end
+              result = if calls[:around].presence
+                         around_chain.call(**kwargs)
+                       else
+                         super(**kwargs)
+                       end
+              calls[:after]&.each do |target|
+                target.is_a?(Symbol) ? send(target, **kwargs) : instance_exec(**kwargs, &target)
+              end
+              result
+            end
+          else
+            # Setup the method to only take args
+            define_method(method.name.to_sym) do |*args|
+              calls[:before]&.each do |target|
+                target.is_a?(Symbol) ? send(target, *args) : instance_exec(*args, &target)
+              end
+              orig_call = proc { |*a| super(*a) }
+              around_chain = calls[:around].inject(orig_call) do |inner, target|
+                proc { |*a| send(target, *a, &inner) }
+              end
+              result = if calls[:around].presence
+                         around_chain.call(*args)
+                       else
+                         super(*args)
+                       end
+              calls[:after]&.each do |target|
+                target.is_a?(Symbol) ? send(target, *args) : instance_exec(*args, &target)
+              end
+              result
+            end
+          end
+        end
+      end
+      private_class_method :create_override_module
     end
   end
 end