dsl_compose 2.15.1 → 2.15.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae01b58f13f59318a89b06b444bd0dc0a17487e66d03a7701cb605673774f75a
-  data.tar.gz: 2feeab8f8494a6dea3ee59c52903a21c84cde2da623f406aea9530581146d124
+  metadata.gz: 0c630022da7a35c7bb15fcb5847b3036dc21e45b0afd950edb4fa6bb205147f4
+  data.tar.gz: ed8a49a2b1ec77a4a741a1eeaddd4fb52019ad307cf96c2d8f531f1df4d24a7f
 SHA512:
-  metadata.gz: 6d1b476aef66fcaf034b3e7775a91233b69f30dc46c1dfc6d2891596ed859d0a9219e69c7bfec5ede49179d56a0fa2e59f31398b5b95504eb8ebd72c6f9a4d01
-  data.tar.gz: 565b63fb9b5e24f6d778e74f477b7aea4cd6619bfb39aa5ae62a9651daffd5b54e06ceaa8cef3378c111b508babe89d55d02af768c0692f24e4be9c68ad23845
+  metadata.gz: 96aa671032ce71ce1d7639ab8fbf25d7e3f17d58f3b822a1601b6af99808502083d284b4f6cbea7541dc271a8d1dcf0e005f98d066852d86a9b88d3e194125cb
+  data.tar.gz: 5d17dfa43b30dae88aebdff5bc192d083fa3cf668e896a9fb71c314304b9b8320a4dfb6444b1055b8fde0d0da45d0285d38982ae7cbcf006d93f1c634d86ca38

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [2.15.4](https://github.com/craigulliott/dsl_compose/compare/v2.15.3...v2.15.4) (2023-10-04)
+
+
+### Bug Fixes
+
+* passing context along with where DSL's were defined, and then including this context in error messages ([5238a3d](https://github.com/craigulliott/dsl_compose/commit/5238a3daa8c1a32e77783d56c7c429b6335995bd))
+
+## [2.15.3](https://github.com/craigulliott/dsl_compose/compare/v2.15.2...v2.15.3) (2023-10-03)
+
+
+### Bug Fixes
+
+* updating class sorting method so that it is stable (we were getting different results on ubuntu/the CI server) ([70139a1](https://github.com/craigulliott/dsl_compose/commit/70139a11fa5190c3019e95199656385676a10177))
+
+## [2.15.2](https://github.com/craigulliott/dsl_compose/compare/v2.15.1...v2.15.2) (2023-10-03)
+
+
+### Bug Fixes
+
+* fix: sorting classes by ancestry chain (i.e. ancestors before descendants) in the parser ([c301c4b](https://github.com/craigulliott/dsl_compose/commit/c301c4b9e1393c996d5b29dd7a6fd0e2758ae109))
+
 ## [2.15.1](https://github.com/craigulliott/dsl_compose/compare/v2.15.0...v2.15.1) (2023-10-03)
 
 

data/lib/dsl_compose/composer.rb

@@ -48,9 +48,11 @@ module DSLCompose
 
           # add a singleton method with the name of this new DSL onto our class, this is how our new DSL will be accessed
           define_singleton_method name do |*args, &block|
+            called_from = caller(1..1).first
+
             # when it is called, we process this new dynamic DSL with the interpreter
             # `self` here is the class in which the dsl is being used, not the class in which the DSL was defined
-            interpreter.execute_dsl self, dsl, *args, &block
+            interpreter.execute_dsl self, dsl, called_from, *args, &block
           end
 
         end

data/lib/dsl_compose/dsl/arguments/argument.rb

@@ -127,7 +127,7 @@ module DSLCompose
             Interpreter.new(self).instance_eval(&block)
           end
         rescue => e
-          raise e, "Error defining argument #{name}: #{e.message}", e.backtrace
+          raise e, "Error while defining argument #{name}\n#{e.message}", e.backtrace
         end
 
         # Set the description for this Argument to the provided value.

data/lib/dsl_compose/dsl/dsl_method.rb

@@ -60,7 +60,7 @@ module DSLCompose
           Interpreter.new(self).instance_eval(&block)
         end
       rescue => e
-        raise e, "Error defining method #{name}: #{e.message}", e.backtrace
+        raise e, "Error while defining method #{name}\n#{e.message}", e.backtrace
       end
 
       # Set the description for this DSLMethod to the provided value.

data/lib/dsl_compose/dsl.rb

@@ -83,8 +83,6 @@ module DSLCompose
       else
         raise NoBlockProvidedError, "No block was provided for this DSL"
       end
-    rescue => e
-      raise e, "Error defining DSL #{@name} on #{@klass}: #{e.message}", e.backtrace
     end
 
     # Set the description for this DSL to the provided value.

data/lib/dsl_compose/interpreter/execution/arguments.rb

@@ -4,25 +4,27 @@ module DSLCompose
   class Interpreter
     class Execution
       class Arguments
-        class MissingRequiredArgumentsError < StandardError
+        class MissingRequiredArgumentsError < InterpreterError
         end
 
-        class TooManyArgumentsError < StandardError
+        class TooManyArgumentsError < InterpreterError
         end
 
-        class OptionalArgumentsShouldBeHashError < StandardError
+        class OptionalArgumentsShouldBeHashError < InterpreterError
         end
 
-        class InvalidArgumentTypeError < StandardError
+        class InvalidArgumentTypeError < InterpreterError
         end
 
-        class ArrayNotValidError < StandardError
+        class ArrayNotValidError < InterpreterError
         end
 
         attr_reader :arguments
+        attr_reader :called_from
 
-        def initialize arguments, *args
+        def initialize arguments, called_from, *args
           @arguments = {}
+          @called_from = called_from
 
           required_argument_count = arguments.required_arguments.count
           required_non_kwarg_argument_count = arguments.required_arguments.count { |a| !a.kwarg }
@@ -40,7 +42,7 @@ module DSLCompose
           required_kwargs = arguments.required_arguments.filter { |a| a.kwarg }
 
           if required_kwargs.any? && !all_kwargs.is_a?(Hash)
-            raise MissingRequiredArgumentsError, "This has required keyword arguments, but no keyword arguments were provided"
+            raise MissingRequiredArgumentsError.new("This has required keyword arguments, but no keyword arguments were provided", called_from)
           end
 
           required_kwargs.each do |required_kwarg|
@@ -51,7 +53,7 @@ module DSLCompose
               # left with only the optional args
               all_kwargs.delete required_kwarg.name
             else
-              raise MissingRequiredArgumentsError, "The required kwarg `#{required_kwarg.name}` was not provided"
+              raise MissingRequiredArgumentsError.new("The required kwarg `#{required_kwarg.name}` was not provided", called_from)
             end
           end
 
@@ -61,12 +63,12 @@ module DSLCompose
 
           # assert that a value is provided for every required argument
           unless required_argument_count == required_args.count
-            raise MissingRequiredArgumentsError, "This requires #{required_non_kwarg_argument_count} arguments, but only #{required_args.count} were provided"
+            raise MissingRequiredArgumentsError.new("This requires #{required_non_kwarg_argument_count} arguments, but only #{required_args.count} were provided", called_from)
           end
 
           # assert that too many arguments have not been provided
           if args.count > required_argument_count + (has_optional_arguments ? 1 : 0)
-            raise TooManyArgumentsError, "Too many arguments provided"
+            raise TooManyArgumentsError.new("Too many arguments provided", called_from)
           end
 
           # Assume all optonal arguments are their defaults (except booleans, which default to false).
@@ -88,7 +90,7 @@ module DSLCompose
           # asset that, if provided, then the optional argument (always the last one) is a Hash
           if has_optional_arguments && !optional_arg.nil?
             unless optional_arg.is_a? Hash
-              raise OptionalArgumentsShouldBeHashError, "If provided, then the optional arguments must be last, and be represented as a Hash"
+              raise OptionalArgumentsShouldBeHashError.new("If provided, then the optional arguments must be last, and be represented as a Hash", called_from)
             end
 
             # assert the each provided optional argument is valid
@@ -110,7 +112,7 @@ module DSLCompose
               end
 
               if optional_arg_value.is_a?(Array) && !optional_argument.array
-                raise ArrayNotValidError, "An array was provided to an argument which does not accept an array of values"
+                raise ArrayNotValidError.new("An array was provided to an argument which does not accept an array of values", called_from)
               end
 
               # to simplify the code, we always process the reset of the validations as an array, even
@@ -121,38 +123,38 @@ module DSLCompose
                 case optional_argument.type
                 when :integer
                   unless value.is_a? Integer
-                    raise InvalidArgumentTypeError, "`#{value}` is not an Integer"
+                    raise InvalidArgumentTypeError.new("`#{value}` is not an Integer", called_from)
                   end
                   optional_argument.validate_integer! value
 
                 when :float
                   # float allows either floats or integers
                   unless value.is_a?(Float) || value.is_a?(Integer)
-                    raise InvalidArgumentTypeError, "`#{value}` is not an Float or Integer"
+                    raise InvalidArgumentTypeError.new("`#{value}` is not an Float or Integer", called_from)
                   end
                   optional_argument.validate_float! value
 
                 when :symbol
                   unless value.is_a? Symbol
-                    raise InvalidArgumentTypeError, "`#{value}` is not a Symbol"
+                    raise InvalidArgumentTypeError.new("`#{value}` is not a Symbol", called_from)
                   end
                   optional_argument.validate_symbol! value
 
                 when :string
                   unless value.is_a? String
-                    raise InvalidArgumentTypeError, "`#{value}` is not a String"
+                    raise InvalidArgumentTypeError.new("`#{value}` is not a String", called_from)
                   end
                   optional_argument.validate_string! value
 
                 when :boolean
                   unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
-                    raise InvalidArgumentTypeError, "`#{value}` is not a boolean"
+                    raise InvalidArgumentTypeError.new("`#{value}` is not a boolean", called_from)
                   end
                   optional_argument.validate_boolean! value
 
                 when :class
                   unless value.is_a?(ClassCoerce)
-                    raise InvalidArgumentTypeError, "`#{value}` is not a class coerce (String)"
+                    raise InvalidArgumentTypeError.new("`#{value}` is not a class coerce (String)", called_from)
                   end
                   optional_argument.validate_class! value
 
@@ -160,7 +162,7 @@ module DSLCompose
                   optional_argument.validate_object! value
 
                 else
-                  raise InvalidArgumentTypeError, "The argument value `#{value}` is not a supported type"
+                  raise InvalidArgumentTypeError.new("The argument value `#{value}` is not a supported type", called_from)
                 end
               end
 
@@ -174,7 +176,7 @@ module DSLCompose
                 optional_arg_value
               end
             rescue => e
-              raise e, "Error processing optional argument #{optional_argument_name}: #{e.message}", e.backtrace
+              raise e, "Error processing optional argument #{optional_argument_name}\n#{e.message}", e.backtrace
             end
 
           end
@@ -200,7 +202,7 @@ module DSLCompose
             end
 
             if required_arg_value.is_a?(Array) && !required_argument.array
-              raise ArrayNotValidError, "An array was provided to an argument which does not accept an array of values"
+              raise ArrayNotValidError.new("An array was provided to an argument which does not accept an array of values", called_from)
             end
 
             # to simplify the code, we always process the reset of the validations as an array, even
@@ -211,38 +213,38 @@ module DSLCompose
               case required_argument.type
               when :integer
                 unless value.is_a? Integer
-                  raise InvalidArgumentTypeError, "`#{value}` is not an Integer"
+                  raise InvalidArgumentTypeError.new("`#{value}` is not an Integer", called_from)
                 end
                 required_argument.validate_integer! value
 
               when :float
                 # float allows either floats or integers
                 unless value.is_a?(Float) || value.is_a?(Integer)
-                  raise InvalidArgumentTypeError, "`#{value}` is not an Float or Integer"
+                  raise InvalidArgumentTypeError.new("`#{value}` is not an Float or Integer", called_from)
                 end
                 required_argument.validate_float! value
 
               when :symbol
                 unless value.is_a? Symbol
-                  raise InvalidArgumentTypeError, "`#{value}` is not a Symbol"
+                  raise InvalidArgumentTypeError.new("`#{value}` is not a Symbol", called_from)
                 end
                 required_argument.validate_symbol! value
 
               when :string
                 unless value.is_a? String
-                  raise InvalidArgumentTypeError, "`#{value}` is not a String"
+                  raise InvalidArgumentTypeError.new("`#{value}` is not a String", called_from)
                 end
                 required_argument.validate_string! value
 
               when :boolean
                 unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
-                  raise InvalidArgumentTypeError, "`#{value}` is not a boolean"
+                  raise InvalidArgumentTypeError.new("`#{value}` is not a boolean", called_from)
                 end
                 required_argument.validate_boolean! value
 
               when :class
                 unless value.is_a?(ClassCoerce)
-                  raise InvalidArgumentTypeError, "`#{value}` is not a class coerce (String)"
+                  raise InvalidArgumentTypeError.new("`#{value}` is not a class coerce (String)", called_from)
                 end
                 required_argument.validate_class! value
 
@@ -250,7 +252,7 @@ module DSLCompose
                 required_argument.validate_object! value
 
               else
-                raise InvalidArgumentTypeError, "The argument `#{value}` is not a supported type"
+                raise InvalidArgumentTypeError.new("The argument `#{value}` is not a supported type", called_from)
               end
             end
 
@@ -264,7 +266,7 @@ module DSLCompose
               required_arg_value
             end
           rescue => e
-            raise e, "Error processing required argument #{argument_name}: #{e.message}", e.backtrace
+            raise e, "Error processing required argument #{argument_name}\n#{e.message}", e.backtrace
           end
         end
 

data/lib/dsl_compose/interpreter/execution/method_calls/method_call.rb

@@ -5,15 +5,17 @@ module DSLCompose
     class Execution
       class MethodCalls
         class MethodCall
-          class InvalidDescriptionError < StandardError
+          class InvalidDescriptionError < InterpreterError
           end
 
           attr_reader :dsl_method
+          attr_reader :called_from
           attr_reader :arguments
 
-          def initialize dsl_method, *args, &block
+          def initialize dsl_method, called_from, *args, &block
             @dsl_method = dsl_method
-            @arguments = Arguments.new(dsl_method.arguments, *args)
+            @called_from = called_from
+            @arguments = Arguments.new(dsl_method.arguments, called_from, *args)
           end
 
           def method_name
@@ -30,7 +32,7 @@ module DSLCompose
           # generate documentation
           def add_parser_usage_note note
             unless note.is_a?(String) && note.strip.length > 0
-              raise InvalidDescriptionError, "The parser usage description `#{note}` is invalid, it must be of type string and have length greater than 0"
+              raise InvalidDescriptionError.new("The parser usage description `#{note}` is invalid, it must be of type string and have length greater than 0", @called_from)
             end
 
             @parser_usage_notes ||= []

data/lib/dsl_compose/interpreter/execution/method_calls.rb

@@ -14,16 +14,18 @@ module DSLCompose
           @method_calls.filter { |mc| mc.method_name == method_name }.any?
         end
 
-        def add_method_call(dsl_method, ...)
+        def add_method_call(dsl_method, called_from, ...)
           # make sure we always have a variable which can be used in the exception message
+          # set to nil first, so that if we get an exception while setting them
+          # it wont break the error message generation
           dsl_method_name = nil
           dsl_method_name = dsl_method.name
 
-          method_call = MethodCall.new(dsl_method, ...)
+          method_call = MethodCall.new(dsl_method, called_from, ...)
           @method_calls << method_call
           method_call
         rescue => e
-          raise e, "Error while executing method #{dsl_method_name}: #{e.message}", e.backtrace
+          raise e, "Error while executing method #{dsl_method_name}\n#{e.message}", e.backtrace
         end
 
         def method_calls_by_name method_name

data/lib/dsl_compose/interpreter/execution.rb

@@ -3,26 +3,28 @@
 module DSLCompose
   class Interpreter
     class Execution
-      class MethodIsUniqueError < StandardError
+      class MethodIsUniqueError < InterpreterError
       end
 
-      class RequiredMethodNotCalledError < StandardError
+      class RequiredMethodNotCalledError < InterpreterError
       end
 
-      class InvalidDescriptionError < StandardError
+      class InvalidDescriptionError < InterpreterError
       end
 
       attr_reader :dsl
+      attr_reader :called_from
       attr_reader :klass
       attr_reader :method_calls
       attr_reader :arguments
 
       # execute/process a dynamically defined DSL
-      def initialize klass, dsl, *args, &block
+      def initialize klass, dsl, called_from, *args, &block
         @klass = klass
         @dsl = dsl
+        @called_from = called_from
         @method_calls = MethodCalls.new
-        @arguments = Arguments.new(dsl.arguments, *args)
+        @arguments = Arguments.new(dsl.arguments, called_from, *args)
 
         # dynamically process the DSL by calling the provided block
         # all methods executions will be caught and processed by the method_missing method below
@@ -34,7 +36,7 @@ module DSLCompose
         dsl.required_dsl_methods.each do |dsl_method|
           unless @method_calls.method_called? dsl_method.name
             dsl_method_name = dsl_method&.name
-            raise RequiredMethodNotCalledError, "The method #{dsl_method_name} is required, but was not called within this DSL"
+            raise RequiredMethodNotCalledError.new("The method #{dsl_method_name} is required, but was not called within this DSL", called_from)
           end
         end
       end
@@ -43,7 +45,7 @@ module DSLCompose
       # generate documentation
       def add_parser_usage_note note
         unless note.is_a?(String) && note.strip.length > 0
-          raise InvalidDescriptionError, "The parser usage description `#{note}` is invalid, it must be of type string and have length greater than 0"
+          raise InvalidDescriptionError.new("The parser usage description `#{note}` is invalid, it must be of type string and have length greater than 0", called_from)
         end
 
         @parser_usage_notes ||= []
@@ -60,15 +62,17 @@ module DSLCompose
 
       # catch and process any method calls within the DSL block
       def method_missing(method_name, ...)
+        called_from = caller(1..1).first
+
         # if the method does not exist, then this will raise a MethodDoesNotExistError
         dsl_method = @dsl.dsl_method method_name
 
         # if the method is unique, then it can only be called once per DSL
         if dsl_method.unique? && @method_calls.method_called?(method_name)
-          raise MethodIsUniqueError, "This method `#{method_name}` is unique and can only be called once within this DSL"
+          raise MethodIsUniqueError.new("This method `#{method_name}` is unique and can only be called once within this DSL", called_from)
         end
 
-        @method_calls.add_method_call(dsl_method, ...)
+        @method_calls.add_method_call(dsl_method, called_from, ...)
       end
 
       def respond_to_missing?(method_name, *args)

data/lib/dsl_compose/interpreter/interpreter_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class Interpreter
+    class InterpreterError < StandardError
+      attr_reader :original_context
+
+      def initialize(message, original_context)
+        super(message)
+        @original_context = original_context
+      end
+
+      def to_s
+        "#{super}\ndsl source: #{@original_context}"
+      end
+    end
+  end
+end

data/lib/dsl_compose/interpreter.rb

@@ -4,10 +4,7 @@ module DSLCompose
   # The class is reponsible for parsing and executing a dynamic DSL (dynamic DSLs are
   # created using the DSLCompose::DSL class).
   class Interpreter
-    class DSLExecutionNotFoundError < StandardError
-    end
-
-    class InvalidDescriptionError < StandardError
+    class InvalidDescriptionError < InterpreterError
     end
 
     # A dynamic DSL can be used multiple times on the same class, each time the DSL is used
@@ -23,7 +20,7 @@ module DSLCompose
     # generate documentation
     def add_parser_usage_note child_class, note
       unless note.is_a?(String) && note.strip.length > 0
-        raise InvalidDescriptionError, "The parser usage description `#{note}` is invalid, it must be of type string and have length greater than 0"
+        raise InvalidDescriptionError.new("The parser usage description `#{note}` is invalid, it must be of type string and have length greater than 0", called_from)
       end
       @parser_usage_notes ||= {}
       @parser_usage_notes[child_class] ||= []
@@ -40,20 +37,23 @@ module DSLCompose
     # Execute/process a dynamically defined DSL on a class.
     # `klass` is the class in which the DSL is being used, not
     # the class in which the DSL was defined.
-    def execute_dsl(klass, dsl, ...)
+    def execute_dsl(klass, dsl, called_from, ...)
       # make sure we have these variables for the exception message below
+      # set to nil first, so that if we get an exception while setting them
+      # it wont break the error message generation
       class_name = nil
-      class_name = klass.name
       dsl_name = nil
+      class_name = klass.name
       dsl_name = dsl.name
 
-      execution = Execution.new(klass, dsl, ...)
+      execution = Execution.new(klass, dsl, called_from, ...)
       @executions << execution
       execution
     rescue => e
-      raise e, "Error processing dsl #{dsl_name} for class #{class_name}: #{e.message}", e.backtrace
+      raise e, "Error while defining DSL #{dsl_name} for class #{class_name}:\n#{e.message}", e.backtrace
     end
 
+    #
     # Returns an array of all executions for a given class.
     def class_executions klass
       @executions.filter { |e| e.klass == klass }

data/lib/dsl_compose/parser/for_children_of_parser/descendants.rb

@@ -21,13 +21,13 @@ module DSLCompose
             "#{child_class.name.split("::").count}_#{has_descendants(child_class) ? 0 : 1}_#{child_class.name}"
           end
           # then by ansestory chain (i.e. ancestors before descendants)
-          extending_classes.sort do |a, b|
+          extending_classes.sort! do |a, b|
             if a < b
               1
             elsif a > b
               -1
             else
-              0
+              a.name <=> b.name
             end
           end
 

data/lib/dsl_compose/parser/for_children_of_parser/for_dsl_parser/for_method_parser.rb

@@ -28,6 +28,8 @@ module DSLCompose
             @dsl_execution = dsl_execution
             @method_names = method_names
 
+            dsl_name = dsl_execution.dsl.name
+
             # assert that a block was provided
             unless block
               raise NoBlockProvided
@@ -100,6 +102,14 @@ module DSLCompose
 
                 # yeild the block in the context of this class
                 instance_exec(**args, &block)
+              rescue => e
+                # if this is an InterpreterError, then it already has the called_from metadata
+                # just continue raising the original error
+                if e.is_a? Interpreter::InterpreterError
+                  raise
+                end
+                # otherwise, decorate the error with where the DSL was defined
+                raise e, "#{e.message}\nparsing class: #{child_class.name}\ndsl name: #{dsl_name}\ndsl method name: #{method_name}\ndsl source: #{method_call.called_from}", e.backtrace
               end
             end
           end

data/lib/dsl_compose/parser/for_children_of_parser/for_dsl_parser.rb

@@ -108,6 +108,14 @@ module DSLCompose
               @dsl_execution = dsl_execution
               # yield the block in the context of this class
               instance_exec(**args, &block)
+            rescue => e
+              # if this is an InterpreterError, then it already has the called_from metadata
+              # just continue raising the original error
+              if e.is_a? Interpreter::InterpreterError
+                raise
+              end
+              # otherwise, decorate the error with where the DSL was defined
+              raise e, "#{e.message}\nparsing class: #{child_class.name}\ndsl name: #{dsl_name}\ndsl source: #{dsl_execution.called_from}", e.backtrace
             end
           end
         end

data/lib/dsl_compose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DSLCompose
-  VERSION = "2.15.1"
+  VERSION = "2.15.4"
 end

data/lib/dsl_compose.rb

@@ -34,6 +34,7 @@ require "dsl_compose/reader/execution_reader/arguments_reader"
 
 require "dsl_compose/reader_base"
 
+require "dsl_compose/interpreter/interpreter_error"
 require "dsl_compose/interpreter/execution/method_calls/method_call"
 require "dsl_compose/interpreter/execution/method_calls"
 require "dsl_compose/interpreter/execution/arguments"

data/sig/dsl_compose/interpreter/execution/arguments.rbs

@@ -4,23 +4,24 @@ module DSLCompose
     class Execution
       class Arguments
         attr_reader arguments: Hash[untyped, untyped]
-        def initialize: (untyped arguments, *untyped args) -> void
+        attr_reader called_from: String
+
+        def initialize: (untyped arguments, String called_from, *untyped args) -> void
         def to_h: -> Hash[untyped, untyped]
 
-        class MissingRequiredArgumentsError < StandardError
-          def initialize: (untyped required_count, untyped provided_count) -> void
+        class MissingRequiredArgumentsError < InterpreterError
         end
 
-        class TooManyArgumentsError < StandardError
+        class TooManyArgumentsError < InterpreterError
         end
 
-        class OptionalArgumentsShouldBeHashError < StandardError
+        class OptionalArgumentsShouldBeHashError < InterpreterError
         end
 
-        class InvalidArgumentTypeError < StandardError
+        class InvalidArgumentTypeError < InterpreterError
         end
 
-        class ArrayNotValidError < StandardError
+        class ArrayNotValidError < InterpreterError
         end
       end
     end

data/sig/dsl_compose/interpreter/execution/method_calls/method_call.rbs

@@ -4,21 +4,22 @@ module DSLCompose
     class Execution
       class MethodCalls
         class MethodCall
-          class InvalidDescriptionError < StandardError
-          end
-
           @method_call: MethodCall
           @parser_usage_notes: Array[String]
 
           attr_reader dsl_method: DSL::DSLMethod
+          attr_reader called_from: String
           attr_reader arguments: Arguments
 
-          def initialize: (DSL::DSLMethod dsl_method, *untyped args) -> void
+          def initialize: (DSL::DSLMethod dsl_method, String called_from, *untyped args) -> void
           def method_name: -> Symbol
           def add_parser_usage_note: (String note) -> void
           def parser_usage_notes: () -> Array[String]
 
           def to_h: -> Hash[untyped, untyped]
+
+          class InvalidDescriptionError < InterpreterError
+          end
         end
       end
     end

data/sig/dsl_compose/interpreter/execution/method_calls.rbs

@@ -9,7 +9,7 @@ module DSLCompose
         def method_calls: () -> Array[MethodCall]
         def method_called?: (Symbol method_name) -> bool
         def method_calls_by_name: (Symbol method_name) -> Array[MethodCall]
-        def add_method_call: (DSL::DSLMethod dsl_method, *untyped args) -> MethodCall
+        def add_method_call: (DSL::DSLMethod dsl_method, String called_from, *untyped args) -> MethodCall
       end
     end
   end

data/sig/dsl_compose/interpreter/execution.rbs

@@ -5,11 +5,12 @@ module DSLCompose
       @parser_usage_notes: Array[String]
 
       attr_reader dsl: DSL
+      attr_reader called_from: String
       attr_reader klass: Object
       attr_reader method_calls: MethodCalls
       attr_reader arguments: Arguments
 
-      def initialize: (Object klass, DSL dsl, *untyped args) -> void
+      def initialize: (Object klass, DSL dsl, String called_from, *untyped args) -> void
       def instance_eval: () -> void
       def add_parser_usage_note: (String note) -> void
       def parser_usage_notes: () -> Array[String]
@@ -18,11 +19,15 @@ module DSLCompose
       def method_missing: (Symbol method_name, *untyped args) -> untyped
       def respond_to_missing?: (Symbol method_name, *untyped args) -> untyped
 
-      class MethodIsUniqueError < StandardError
+      class MethodIsUniqueError < InterpreterError
       end
 
-      class RequiredMethodNotCalledError < StandardError
+      class RequiredMethodNotCalledError < InterpreterError
       end
+
+      class InvalidDescriptionError < InterpreterError
+      end
+
     end
   end
 end

data/sig/dsl_compose/interpreter/interpreter_error.rbs

@@ -0,0 +1,11 @@
+
+# Classes
+module DSLCompose
+  class Interpreter
+    class InterpreterError < StandardError
+      attr_reader original_context: String
+      def initialize: (String message, String original_context) -> void
+      def to_s: -> String
+    end
+  end
+end

data/sig/dsl_compose/interpreter.rbs

@@ -12,10 +12,7 @@ module DSLCompose
     def add_parser_usage_note: (singleton(Object) klass, String note) -> void
     def parser_usage_notes: (singleton(Object) klass) -> Array[String]
 
-    class InvalidDescriptionError < StandardError
-    end
-
-    class DSLExecutionNotFoundError < StandardError
+    class InvalidDescriptionError < InterpreterError
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_compose
 version: !ruby/object:Gem::Version
-  version: 2.15.1
+  version: 2.15.4
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2023-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: class_spec_helper
@@ -67,6 +67,7 @@ files:
 - lib/dsl_compose/interpreter/execution/arguments.rb
 - lib/dsl_compose/interpreter/execution/method_calls.rb
 - lib/dsl_compose/interpreter/execution/method_calls/method_call.rb
+- lib/dsl_compose/interpreter/interpreter_error.rb
 - lib/dsl_compose/parser.rb
 - lib/dsl_compose/parser/block_arguments.rb
 - lib/dsl_compose/parser/for_children_of_parser.rb
@@ -109,6 +110,7 @@ files:
 - sig/dsl_compose/interpreter/execution/arguments.rbs
 - sig/dsl_compose/interpreter/execution/method_calls.rbs
 - sig/dsl_compose/interpreter/execution/method_calls/method_call.rbs
+- sig/dsl_compose/interpreter/interpreter_error.rbs
 - sig/dsl_compose/parser.rbs
 - sig/dsl_compose/parser/block_arguments.rbs
 - sig/dsl_compose/parser/for_children_of_parser.rbs