dsl_compose 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51a691703918ebafb30bb7c158e627e6a02597e9171e38d1b87cd4cd066d825d
-  data.tar.gz: 4e750c6839f7946299f13e81b8af0a7ca94e8d852d7a418f8be97658a0ba67a8
+  metadata.gz: 461fe3b90a0a36703aee0be51b3594472d2fc55ff1eab2b6b5bfabd851446d09
+  data.tar.gz: 65ba43be5dfcefbaf5588744b66fcd73a8266abbea65bcb59699132c43ed47a7
 SHA512:
-  metadata.gz: aa82b56b1c7b6cfcbf4b0116c34b4084f5873cd5d957ceb615b16ab4b36f44a6d3da1ffea8a8ef779b837322d0622254e8688fa4fecffdcb6a011a531aa31106
-  data.tar.gz: b1d02bc6e922d35aeee52095bfd3847d5ae347ef56e6278a4f90bb4c76666e0829dad6638956f96a555400a129160f5431d197b264dc1103532c2a1b6df14de2
+  metadata.gz: 9d2b86c2398b49217ba29152f68f6666e0bcbe926d4adadaac29b4f4a3d8500b120192c469c4fa25f68b68c58e73782459356a7845bcabb0237076521e4e0f37
+  data.tar.gz: 4f58959006d911cb13d75ccddc1871416736236d0e278844f6beb1c22a546d2e8d3620230931a2108c8949ad346a65ce27f3ae437fd8d55e5563603ad8421d24

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.7.0](https://github.com/craigulliott/dsl_compose/compare/v1.6.0...v1.7.0) (2023-07-07)
+
+
+### Features
+
+* better error messages ([#19](https://github.com/craigulliott/dsl_compose/issues/19)) ([a9afa6c](https://github.com/craigulliott/dsl_compose/commit/a9afa6cb1b7482d0d7a646b6872ca5e969393eb7))
+
 ## [1.6.0](https://github.com/craigulliott/dsl_compose/compare/v1.5.0...v1.6.0) (2023-07-07)
 
 

data/lib/dsl_compose/composer.rb

@@ -3,26 +3,17 @@
 module DSLCompose
   module Composer
     class ComposerAlreadyInstalledError < StandardError
-      def message
-        "This module has already been included or the define_dsl singleton method already exists for this class."
-      end
     end
 
     class MethodAlreadyExistsWithThisDSLNameError < StandardError
-      def message
-        "The `define_dsl` singleton method already exists for this class."
-      end
     end
 
     class GetDSLExecutionResultsMethodAlreadyExistsError < StandardError
-      def message
-        "The `dsls` singleton method already exists for this class."
-      end
     end
 
     def self.included klass
       if (klass.private_methods + klass.methods).include? :define_dsl
-        raise ComposerAlreadyInstalledError
+        raise ComposerAlreadyInstalledError, "This module has already been included or the define_dsl singleton method already exists for this class."
       end
 
       # create an interpreter for this class which will be shared by all child classes and all
@@ -31,7 +22,7 @@ module DSLCompose
 
       # return a specific DSL which is defined for this class
       if klass.respond_to? :dsls
-        raise GetDSLExecutionResultsMethodAlreadyExistsError
+        raise GetDSLExecutionResultsMethodAlreadyExistsError, "The `dsls` singleton method already exists for this class."
       end
 
       klass.define_singleton_method :dsls do
@@ -52,7 +43,7 @@ module DSLCompose
 
           # ensure that creating this DSL will not override any existing methods on this class
           if respond_to? name
-            raise MethodAlreadyExistsWithThisDSLNameError
+            raise MethodAlreadyExistsWithThisDSLNameError, "The `define_dsl` singleton method `#{name}` already exists for this class."
           end
 
           # add a singleton method with the name of this new DSL onto our class, this is how our new DSL will be accessed

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

@@ -6,9 +6,6 @@ module DSLCompose
       class Argument
         class EqualToValidation
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize value
@@ -16,7 +13,7 @@ module DSLCompose
           end
 
           def validate! value
-            raise ValidationFailedError unless value == @value
+            raise ValidationFailedError, "The argument is invalid. Expected #{@value} but received #{value}" unless value == @value
           end
         end
       end

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

@@ -6,9 +6,6 @@ module DSLCompose
       class Argument
         class FormatValidation
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize regex
@@ -16,7 +13,7 @@ module DSLCompose
           end
 
           def validate! value
-            raise ValidationFailedError if @regex.match(value).nil?
+            raise ValidationFailedError, "The argument is invalid. Expected format #{@regex} but received #{value}" if @regex.match(value).nil?
           end
         end
       end

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

@@ -6,27 +6,21 @@ module DSLCompose
       class Argument
         class GreaterThanOrEqualToValidation
           class InvalidValueError < StandardError
-            def message
-              "The value provided to validate_greater_than must be a number"
-            end
           end
 
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize value
             unless value.is_a?(Numeric)
-              raise InvalidValueError
+              raise InvalidValueError, "The value `#{value}` provided to this validator must be of type number"
             end
 
             @value = value
           end
 
           def validate! value
-            raise ValidationFailedError unless value >= @value
+            raise ValidationFailedError, "The argument is invalid. Expected greater than or equal to #{@value} but received #{value}" unless value >= @value
           end
         end
       end

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

@@ -6,27 +6,21 @@ module DSLCompose
       class Argument
         class GreaterThanValidation
           class InvalidValueError < StandardError
-            def message
-              "The value provided to validate_greater_than must be a number"
-            end
           end
 
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize value
             unless value.is_a?(Numeric)
-              raise InvalidValueError
+              raise InvalidValueError, "The value `#{value}` provided to this validator must be of type number"
             end
 
             @value = value
           end
 
           def validate! value
-            raise ValidationFailedError unless value > @value
+            raise ValidationFailedError, "The argument is invalid. Expected greater than #{@value} but received #{value}" unless value > @value
           end
         end
       end

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

@@ -6,27 +6,21 @@ module DSLCompose
       class Argument
         class InValidation
           class InvalidValueError < StandardError
-            def message
-              "The value provided to validate_greater_than must be a number"
-            end
           end
 
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize values
             unless values.is_a?(Array)
-              raise InvalidValueError
+              raise InvalidValueError, "The value `#{values}` provided to this validator must be of type Array"
             end
 
             @values = values
           end
 
           def validate! value
-            raise ValidationFailedError unless @values.include? value
+            raise ValidationFailedError, "The argument is invalid. Expected in #{@values} but received #{value}" unless @values.include? value
           end
         end
       end

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

@@ -6,9 +6,6 @@ module DSLCompose
       class Argument
         class LengthValidation
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize maximum: nil, minimum: nil, is: nil
@@ -20,17 +17,17 @@ module DSLCompose
           def validate! value
             maximum = @maximum
             unless maximum.nil?
-              raise ValidationFailedError if value.length > maximum
+              raise ValidationFailedError, "The argument is invalid. Expected #{value} to be less than or equal to #{maximum} characters" if value.length > maximum
             end
 
             minimum = @minimum
             unless minimum.nil?
-              raise ValidationFailedError if value.length < minimum
+              raise ValidationFailedError, "The argument is invalid. Expected #{value} to be greater than or equal to #{minimum} characters" if value.length < minimum
             end
 
             is = @is
             unless is.nil?
-              raise ValidationFailedError if value.length != is
+              raise ValidationFailedError, "The argument is invalid. Expected #{value} to be #{is} characters long" if value.length != is
             end
 
             true

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

@@ -6,27 +6,21 @@ module DSLCompose
       class Argument
         class LessThanOrEqualToValidation
           class InvalidValueError < StandardError
-            def message
-              "The value provided to validate_greater_than must be a number"
-            end
           end
 
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize value
             unless value.is_a?(Numeric)
-              raise InvalidValueError
+              raise InvalidValueError, "The value `#{value}` provided to this validator must be of type number"
             end
 
             @value = value
           end
 
           def validate! value
-            raise ValidationFailedError unless value <= @value
+            raise ValidationFailedError, "The argument is invalid. Expected less than or equal to #{@value} but received #{value}" unless value <= @value
           end
         end
       end

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

@@ -6,27 +6,21 @@ module DSLCompose
       class Argument
         class LessThanValidation
           class InvalidValueError < StandardError
-            def message
-              "The value provided to validate_greater_than must be a number"
-            end
           end
 
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize value
             unless value.is_a?(Numeric)
-              raise InvalidValueError
+              raise InvalidValueError, "The value `#{value}` provided to this validator must be of type number"
             end
 
             @value = value
           end
 
           def validate! value
-            raise ValidationFailedError unless value < @value
+            raise ValidationFailedError, "The argument is invalid. Expected less than #{@value} but received #{value}" unless value < @value
           end
         end
       end

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

@@ -6,27 +6,21 @@ module DSLCompose
       class Argument
         class NotInValidation
           class InvalidValueError < StandardError
-            def message
-              "The value provided to validate_greater_than must be a number"
-            end
           end
 
           class ValidationFailedError < StandardError
-            def message
-              "The argument is invalid"
-            end
           end
 
           def initialize values
             unless values.is_a?(Array)
-              raise InvalidValueError
+              raise InvalidValueError, "The value `#{values}` provided to this validator must be of type Array"
             end
 
             @values = values
           end
 
           def validate! value
-            raise ValidationFailedError if @values.include?(value)
+            raise ValidationFailedError, "The argument is invalid. Expected not in #{@values} but received #{value}" if @values.include?(value)
           end
         end
       end

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

@@ -5,45 +5,27 @@ module DSLCompose
     class Arguments
       class Argument
         class ValidationIncompatibleError < StandardError
-          def message
-            "The validation is not compatible with this argument type"
-          end
         end
 
         class ValidationAlreadyExistsError < StandardError
-          def message
-            "This validation has already been applied to this method option."
-          end
         end
 
         class InvalidTypeError < StandardError
-          def message
-            "Argument type must be one of :integer, :boolean, :float, :string or :symbol"
-          end
         end
 
         class InvalidNameError < StandardError
-          def message
-            "The option name is invalid, it must be of type symbol."
-          end
         end
 
         class InvalidDescriptionError < StandardError
-          def message
-            "The option description is invalid, it must be of type string and have length greater than 0."
-          end
         end
 
         class DescriptionAlreadyExistsError < StandardError
-          def message
-            "The description has already been set"
-          end
         end
 
         class ArgumentNameReservedError < StandardError
-          def message
-            "This argument name is a reserved word. The names #{RESERVED_ARGUMENT_NAMES.join ", "} can not be used here because the Parser uses it to express a structural part of the DSL"
-          end
+        end
+
+        class ValidationInvalidArgumentError < StandardError
         end
 
         RESERVED_ARGUMENT_NAMES = [
@@ -87,18 +69,18 @@ module DSLCompose
           if name.is_a? Symbol
 
             if RESERVED_ARGUMENT_NAMES.include? name
-              raise ArgumentNameReservedError
+              raise ArgumentNameReservedError, "This argument name `#{name}` is a reserved word. The names #{RESERVED_ARGUMENT_NAMES.join ", "} can not be used here because the Parser uses them to express a structural part of the DSL"
             end
 
             @name = name
           else
-            raise InvalidNameError
+            raise InvalidNameError, "The option name `#{name}` is invalid, it must be of type symbol."
           end
 
           if type == :integer || type == :boolean || type == :float || type == :string || type == :symbol
             @type = type
           else
-            raise InvalidTypeError
+            raise InvalidTypeError, "Argument type `#{type}` must be one of :integer, :boolean, :float, :string or :symbol"
           end
 
           @required = required ? true : false
@@ -111,6 +93,8 @@ module DSLCompose
           if block
             Interpreter.new(self).instance_eval(&block)
           end
+        rescue => e
+          raise e, "Error defining argument #{name}: #{e.message}", e.backtrace
         end
 
         # Set the description for this Argument to the provided value.
@@ -119,11 +103,11 @@ module DSLCompose
         # The `description` can only be set once per Argument
         def set_description description
           unless description.is_a?(String) && description.length > 0
-            raise InvalidDescriptionError
+            raise InvalidDescriptionError, "The option description `#{description}` is invalid, it must be of type string and have length greater than 0."
           end
 
           if has_description?
-            raise DescriptionAlreadyExistsError
+            raise DescriptionAlreadyExistsError, "The description has already been set"
           end
 
           @description = description
@@ -146,11 +130,15 @@ module DSLCompose
 
         def validate_greater_than value
           if @greater_than_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `greater_than` has already been applied to this method option."
+          end
+
+          unless value.is_a?(Numeric)
+            raise ValidationInvalidArgumentError, value
           end
 
           unless @type == :integer || @type == :float
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @greater_than_validation = GreaterThanValidation.new value
@@ -158,15 +146,15 @@ module DSLCompose
 
         def validate_greater_than_or_equal_to value
           if @greater_than_or_equal_to_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `greater_than_or_equal_to` has already been applied to this method option."
           end
 
           unless value.is_a?(Numeric)
-            raise ValidationInvalidArgumentError
+            raise ValidationInvalidArgumentError, value
           end
 
           unless @type == :integer || @type == :float
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @greater_than_or_equal_to_validation = GreaterThanOrEqualToValidation.new value
@@ -174,15 +162,15 @@ module DSLCompose
 
         def validate_less_than value
           if @less_than_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `less_than` has already been applied to this method option."
           end
 
           unless value.is_a?(Numeric)
-            raise ValidationInvalidArgumentError
+            raise ValidationInvalidArgumentError, value
           end
 
           unless @type == :integer || @type == :float
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @less_than_validation = LessThanValidation.new value
@@ -190,15 +178,15 @@ module DSLCompose
 
         def validate_less_than_or_equal_to value
           if @less_than_or_equal_to_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `less_than_or_equal_to` has already been applied to this method option."
           end
 
           unless value.is_a?(Numeric)
-            raise ValidationInvalidArgumentError
+            raise ValidationInvalidArgumentError, value
           end
 
           unless @type == :integer || @type == :float
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @less_than_or_equal_to_validation = LessThanOrEqualToValidation.new value
@@ -206,26 +194,26 @@ module DSLCompose
 
         def validate_format regexp
           if @format_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `format` has already been applied to this method option."
           end
 
           unless regexp.is_a? Regexp
-            raise ValidationInvalidArgumentError
+            raise ValidationInvalidArgumentError, regexp
           end
 
           unless @type == :string || @type == :symbol
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
           @format_validation = FormatValidation.new regexp
         end
 
         def validate_equal_to value
           if @equal_to_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `equal_to` has already been applied to this method option."
           end
 
           unless @type == :integer || @type == :float || @type == :string || @type == :symbol || @type == :boolean
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @equal_to_validation = EqualToValidation.new value
@@ -233,15 +221,15 @@ module DSLCompose
 
         def validate_in values
           if @in_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `in` has already been applied to this method option."
           end
 
           unless values.is_a? Array
-            raise ValidationInvalidArgumentError
+            raise ValidationInvalidArgumentError, values
           end
 
           unless @type == :integer || @type == :float || @type == :string || @type == :symbol
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @in_validation = InValidation.new values
@@ -249,15 +237,15 @@ module DSLCompose
 
         def validate_not_in values
           if @not_in_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `not_in` has already been applied to this method option."
           end
 
           unless values.is_a? Array
-            raise ValidationInvalidArgumentError
+            raise ValidationInvalidArgumentError, values
           end
 
           unless @type == :integer || @type == :float || @type == :string || @type == :symbol
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @not_in_validation = NotInValidation.new values
@@ -265,11 +253,11 @@ module DSLCompose
 
         def validate_length maximum: nil, minimum: nil, is: nil
           if @length_validation
-            raise ValidationAlreadyExistsError
+            raise ValidationAlreadyExistsError, "The validation `length` has already been applied to this method option."
           end
 
           unless @type == :string || @type == :symbol
-            raise ValidationIncompatibleError
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
           end
 
           @length_validation = LengthValidation.new(maximum: maximum, minimum: minimum, is: is)

data/lib/dsl_compose/dsl/arguments.rb

@@ -4,33 +4,18 @@ module DSLCompose
   class DSL
     class Arguments
       class ArgumentDoesNotExistError < StandardError
-        def message
-          "This argument does not exist for this DSLMethod"
-        end
       end
 
       class ArgumentOrderingError < StandardError
-        def message
-          "Required arguments can not be added after optional ones"
-        end
       end
 
       class ArgumentAlreadyExistsError < StandardError
-        def message
-          "An argument with this name already exists for this DSL method"
-        end
       end
 
       class RequestedOptionalArgumentIsRequiredError < StandardError
-        def message
-          "A specific argument which was expected to be optional was requested, but the argument found was flagged as required"
-        end
       end
 
       class RequestedRequiredArgumentIsOptionalError < StandardError
-        def message
-          "A specific argument which was expected to be required was requested, but the argument found was flagged as optional"
-        end
       end
 
       def initialize
@@ -58,7 +43,7 @@ module DSLCompose
         if has_argument? name
           @arguments[name]
         else
-          raise ArgumentDoesNotExistError
+          raise ArgumentDoesNotExistError, "The argument `#{name}` does not exist for this DSLMethod"
         end
       end
 
@@ -69,7 +54,7 @@ module DSLCompose
         if arg.optional?
           @arguments[name]
         else
-          raise RequestedOptionalArgumentIsRequiredError
+          raise RequestedOptionalArgumentIsRequiredError, "A specific argument `#{name}` which was expected to be optional was requested, but the argument found was flagged as required"
         end
       end
 
@@ -80,7 +65,7 @@ module DSLCompose
         if arg.required?
           @arguments[name]
         else
-          raise RequestedRequiredArgumentIsOptionalError
+          raise RequestedRequiredArgumentIsOptionalError, "A specific argument `#{name}` which was expected to be required was requested, but the argument found was flagged as optional"
         end
       end
 
@@ -98,12 +83,12 @@ module DSLCompose
       # or optional on the method which is exposed in our DSL.
       def add_argument name, required, type, &block
         if @arguments.key? name
-          raise ArgumentAlreadyExistsError
+          raise ArgumentAlreadyExistsError, "An argument with the name `#{name}` already exists for this DSL method"
         end
 
         # required arguments may not come after optional ones
         if required && optional_arguments.any?
-          raise ArgumentOrderingError
+          raise ArgumentOrderingError, "Required arguments can not be added after optional ones"
         end
 
         @arguments[name] = Argument.new(name, required, type, &block)

data/lib/dsl_compose/dsl/dsl_method.rb

@@ -3,58 +3,16 @@
 module DSLCompose
   class DSL
     class DSLMethod
-      class ArgumentDoesNotExistError < StandardError
-        def message
-          "This argument does not exist for this DSLMethod"
-        end
-      end
-
       class InvalidNameError < StandardError
-        def message
-          "The method #{method_name} is invalid, it must be of type symbol"
-        end
       end
 
       class MethodNameIsReservedError < StandardError
-        def message
-          "This method already would override an existing internal method"
-        end
       end
 
       class InvalidDescriptionError < StandardError
-        def message
-          "The DSL method description is invalid, it must be of type string and have length greater than 0"
-        end
       end
 
       class DescriptionAlreadyExistsError < StandardError
-        def message
-          "The description has already been set"
-        end
-      end
-
-      class ArgumentOrderingError < StandardError
-        def message
-          "Required arguments can not be added after optional ones"
-        end
-      end
-
-      class ArgumentAlreadyExistsError < StandardError
-        def message
-          "An argument with this name already exists for this DSL method"
-        end
-      end
-
-      class RequestedOptionalArgumentIsRequiredError < StandardError
-        def message
-          "A specific argument which was expected to be optional was requested, but the argument found was flagged as required"
-        end
-      end
-
-      class RequestedRequiredArgumentIsOptionalError < StandardError
-        def message
-          "A specific argument which was expected to be required was requested, but the argument found was flagged as optional"
-        end
       end
 
       # The name of this DSLMethod.
@@ -82,12 +40,12 @@ module DSLCompose
 
           # don't allow methods to override existing internal methods
           if Class.respond_to? name
-            raise MethodNameIsReservedError
+            raise MethodNameIsReservedError, "This method #{name} would override an existing internal method"
           end
 
           @name = name
         else
-          raise InvalidNameError
+          raise InvalidNameError, "The method name `#{name}` is invalid, it must be of type symbol"
         end
 
         @unique = unique ? true : false
@@ -101,6 +59,8 @@ module DSLCompose
         if block
           Interpreter.new(self).instance_eval(&block)
         end
+      rescue => e
+        raise e, "Error defining method #{name}: #{e.message}", e.backtrace
       end
 
       # Set the description for this DSLMethod to the provided value.
@@ -109,11 +69,11 @@ module DSLCompose
       # The `description` can only be set once per DSLMethod
       def set_description description
         unless description.is_a?(String) && description.length > 0
-          raise InvalidDescriptionError
+          raise InvalidDescriptionError, "The DSL method description `#{description}` is invalid, it must be of type string and have length greater than 0"
         end
 
         if has_description?
-          raise DescriptionAlreadyExistsError
+          raise DescriptionAlreadyExistsError, "The description has already been set"
         end
 
         @description = description

data/lib/dsl_compose/dsl.rb

@@ -7,39 +7,21 @@ module DSLCompose
   # by calling `define_dsl` in a class and passing it a block which contains the DSL definition
   class DSL
     class MethodDoesNotExistError < StandardError
-      def message
-        "This method does not exist for this DSL"
-      end
     end
 
     class MethodAlreadyExistsError < StandardError
-      def message
-        "This method already exists for this DSL"
-      end
     end
 
     class InvalidNameError < StandardError
-      def message
-        "This DSL name is invalid, it must be of type symbol"
-      end
     end
 
     class InvalidDescriptionError < StandardError
-      def message
-        "This DSL description is invalid, it must be of type string and have length greater than 0"
-      end
     end
 
     class DescriptionAlreadyExistsError < StandardError
-      def message
-        "The DSL description has already been set"
-      end
     end
 
     class NoBlockProvidedError < StandardError
-      def message
-        "No block was provided for this DSL"
-      end
     end
 
     # The name of this DSL.
@@ -64,7 +46,7 @@ module DSLCompose
       if name.is_a? Symbol
         @name = name
       else
-        raise InvalidNameError
+        raise InvalidNameError, "The DSL name `#{name}` is invalid, it must be of type symbol"
       end
 
       @klass = klass
@@ -81,8 +63,10 @@ module DSLCompose
         # would have access to all of the methods defined in here.
         Interpreter.new(self).instance_eval(&block)
       else
-        raise NoBlockProvidedError
+        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.
@@ -91,11 +75,11 @@ module DSLCompose
     # The `description` can only be set once per DSL
     def set_description description
       unless description.is_a?(String) && description.length > 0
-        raise InvalidDescriptionError
+        raise InvalidDescriptionError, "The DSL description `#{description}` is invalid, it must be of type string and have length greater than 0"
       end
 
       if has_description?
-        raise DescriptionAlreadyExistsError
+        raise DescriptionAlreadyExistsError, "The DSL description has already been set"
       end
 
       @description = description
@@ -112,7 +96,7 @@ module DSLCompose
     # Method `name` must be unique within the DSL.
     def add_method name, unique, required, &block
       if has_dsl_method? name
-        raise MethodAlreadyExistsError
+        raise MethodAlreadyExistsError, "The method `#{name}` already exists for this DSL"
       end
 
       @dsl_methods[name] = DSLMethod.new(name, unique, required, &block)
@@ -139,7 +123,7 @@ module DSLCompose
       if has_dsl_method? name
         @dsl_methods[name]
       else
-        raise MethodDoesNotExistError
+        raise MethodDoesNotExistError, "The method `#{name}` does not exist for this DSL"
       end
     end
 

data/lib/dsl_compose/dsls.rb

@@ -3,21 +3,12 @@
 module DSLCompose
   module DSLs
     class ClassDSLDefinitionDoesNotExistError < StandardError
-      def message
-        "The requested DSL does not exist on this class"
-      end
     end
 
     class DSLAlreadyExistsError < StandardError
-      def message
-        "A DSL with this name already exists"
-      end
     end
 
     class NoDSLDefinitionsForClassError < StandardError
-      def message
-        "No DSLs have been defined for this class"
-      end
     end
 
     # an object to hold all of the defined DSLs in our application, the DSLs are
@@ -30,7 +21,7 @@ module DSLCompose
       @dsls[klass] ||= {}
 
       if @dsls[klass].key? name
-        raise DSLAlreadyExistsError
+        raise DSLAlreadyExistsError, "A DSL with the name `#{name}` already exists"
       end
 
       @dsls[klass][name] = DSLCompose::DSL.new(name, klass)
@@ -53,7 +44,7 @@ module DSLCompose
       if @dsls.key? klass
         @dsls[klass].values
       else
-        raise NoDSLDefinitionsForClassError
+        raise NoDSLDefinitionsForClassError, "No DSLs have been defined for this class"
       end
     end
 
@@ -64,10 +55,10 @@ module DSLCompose
         if @dsls[klass].key? name
           @dsls[klass][name]
         else
-          raise ClassDSLDefinitionDoesNotExistError
+          raise ClassDSLDefinitionDoesNotExistError, "The requested DSL `#{name}` does not exist on this class"
         end
       else
-        raise NoDSLDefinitionsForClassError
+        raise NoDSLDefinitionsForClassError, "No DSLs have been defined for this class"
       end
     end
 

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

@@ -5,27 +5,15 @@ module DSLCompose
     class Execution
       class Arguments
         class MissingRequiredArgumentsError < StandardError
-          def initialize required_count, provided_count
-            super "This requires #{required_count} arguments, but only #{provided_count} were provided"
-          end
         end
 
         class TooManyArgumentsError < StandardError
-          def message
-            "Too many arguments provided"
-          end
         end
 
-        class OptionalArgsShouldBeHashError < StandardError
-          def message
-            "If provided, then the optional arguments must be last, and be represented as a Hash"
-          end
+        class OptionalArgumentsShouldBeHashError < StandardError
         end
 
         class InvalidArgumentTypeError < StandardError
-          def message
-            "The provided argument is the wrong type"
-          end
         end
 
         attr_reader :arguments
@@ -45,18 +33,18 @@ module DSLCompose
 
           # assert that a value is provided for every required argument
           unless required_argument_count == required_args.count
-            raise MissingRequiredArgumentsError.new required_argument_count, required_args.count
+            raise MissingRequiredArgumentsError, "This requires #{required_argument_count} arguments, but only #{required_args.count} were provided"
           end
 
           # assert that too many arguments have not been provided
           if args.count > required_argument_count + (has_optional_arguments ? 1 : 0)
-            raise TooManyArgumentsError
+            raise TooManyArgumentsError, "Too many arguments provided"
           end
 
           # asset that, if provided, then the optional argument (always the last one) is a Hash
           if has_optional_arguments && optional_arg.nil? === false
             unless optional_arg.is_a? Hash
-              raise OptionalArgsShouldBeHashError
+              raise OptionalArgumentsShouldBeHashError, "If provided, then the optional arguments must be last, and be represented as a Hash"
             end
 
             # assert the each provided optional argument is valid
@@ -67,72 +55,82 @@ module DSLCompose
               case optional_argument.type
               when :integer
                 unless optional_arg_value.is_a? Integer
-                  raise InvalidArgumentTypeError
+                  raise InvalidArgumentTypeError, "#{optional_arg_value} is not an Integer"
                 end
                 optional_argument.validate_integer! optional_arg_value
 
               when :symbol
                 unless optional_arg_value.is_a? Symbol
-                  raise InvalidArgumentTypeError
+                  raise InvalidArgumentTypeError, "#{optional_arg_value} is not a Symbol"
                 end
                 optional_argument.validate_symbol! optional_arg_value
 
               when :string
                 unless optional_arg_value.is_a? String
-                  raise InvalidArgumentTypeError
+                  raise InvalidArgumentTypeError, "#{optional_arg_value} is not a String"
                 end
                 optional_argument.validate_string! optional_arg_value
 
               when :boolean
                 unless optional_arg_value.is_a?(TrueClass) || optional_arg_value.is_a?(FalseClass)
-                  raise InvalidArgumentTypeError
+                  raise InvalidArgumentTypeError, "#{optional_arg_value} is not a boolean"
                 end
                 optional_argument.validate_boolean! optional_arg_value
 
               else
-                raise InvalidArgumentTypeError
+                raise InvalidArgumentTypeError, "The argument #{optional_arg_value} is not a supported type"
               end
 
               # the provided value appears valid for this argument, save the value
               @arguments[optional_argument_name] = optional_arg_value
+
+            rescue => e
+              raise e, "Error processing optional argument #{optional_argument_name}: #{e.message}", e.backtrace
             end
 
           end
 
           # validate the value provided to each required argument
           arguments.required_arguments.each_with_index do |required_argument, i|
+            # make sure we always have an argument_name for the exception below
+            argument_name = nil
+            argument_name = required_argument.name
+
             arg = args[i]
             case required_argument.type
             when :integer
               unless arg.is_a? Integer
-                raise InvalidArgumentTypeError
+                raise InvalidArgumentTypeError, "#{arg} is not an Integer"
               end
               required_argument.validate_integer! arg
 
             when :symbol
               unless arg.is_a? Symbol
-                raise InvalidArgumentTypeError
+                raise InvalidArgumentTypeError, "#{arg} is not a Symbol"
               end
               required_argument.validate_symbol! arg
 
             when :string
               unless arg.is_a? String
-                raise InvalidArgumentTypeError
+                raise InvalidArgumentTypeError, "#{arg} is not a String"
               end
               required_argument.validate_string! arg
 
             when :boolean
               unless arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
-                raise InvalidArgumentTypeError
+                raise InvalidArgumentTypeError, "#{arg} is not a boolean"
               end
               required_argument.validate_boolean! arg
 
             else
-              raise InvalidArgumentTypeError
+              raise InvalidArgumentTypeError, "The argument #{arg} is not a supported type"
             end
 
             # the provided value appears valid for this argument, save the value
             @arguments[required_argument.name] = arg
+
+          rescue => e
+            raise e, "Error processing required argument #{argument_name}: #{e.message}", e.backtrace
           end
         end
 

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

@@ -8,30 +8,6 @@ module DSLCompose
           attr_reader :dsl_method
           attr_reader :arguments
 
-          class MissingRequiredArgumentsError < StandardError
-            def initialize required_count, provided_count
-              super "This method requires #{required_count} arguments, but only #{required_count} were provided"
-            end
-          end
-
-          class TooManyArgumentsError < StandardError
-            def message
-              "Too many arguments provided to this method"
-            end
-          end
-
-          class OptionalArgsShouldBeHashError < StandardError
-            def message
-              "If provided, then the optional arguments must be last, and be represented as a Hash"
-            end
-          end
-
-          class InvalidArgumentTypeError < StandardError
-            def message
-              "The provided argument is the wrong type"
-            end
-          end
-
           def initialize dsl_method, *args, &block
             @dsl_method = dsl_method
             @arguments = Arguments.new(dsl_method.arguments, *args)

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

@@ -15,9 +15,15 @@ module DSLCompose
         end
 
         def add_method_call dsl_method, *args, &block
+          # make sure we always have a variable which can be used in the exception message
+          dsl_method_name = nil
+          dsl_method_name = dsl_method.name
+
           method_call = MethodCall.new(dsl_method, *args, &block)
           @method_calls << method_call
           method_call
+        rescue => e
+          raise e, "Error while executing method #{dsl_method_name}: #{e.message}", e.backtrace
         end
 
         def method_calls_by_name method_name

data/lib/dsl_compose/interpreter/execution.rb

@@ -4,15 +4,9 @@ module DSLCompose
   class Interpreter
     class Execution
       class MethodIsUniqueError < StandardError
-        def message
-          "This method is unique and can only be called once within this DSL"
-        end
       end
 
       class RequiredMethodNotCalledError < StandardError
-        def message
-          "This method is required, but was not called within this DSL"
-        end
       end
 
       attr_reader :dsl
@@ -36,7 +30,8 @@ module DSLCompose
         # assert that all required methods have been called at least once
         dsl.required_dsl_methods.each do |dsl_method|
           unless @method_calls.method_called? dsl_method.name
-            raise RequiredMethodNotCalledError
+            dsl_method_name = dsl_method&.name
+            raise RequiredMethodNotCalledError, "The method #{dsl_method_name} is required, but was not called within this DSL"
           end
         end
       end
@@ -50,7 +45,7 @@ module DSLCompose
 
         # 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
+          raise MethodIsUniqueError, "This method `#{method_name}` is unique and can only be called once within this DSL"
         end
 
         @method_calls.add_method_call dsl_method, *args, &block

data/lib/dsl_compose/interpreter.rb

@@ -17,9 +17,17 @@ module DSLCompose
     # `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, *args, &block
+      # make sure we have these variables for the exception message below
+      class_name = nil
+      class_name = klass.name
+      dsl_name = nil
+      dsl_name = dsl.name
+
       execution = Execution.new(klass, dsl, *args, &block)
       @executions << execution
       execution
+    rescue => e
+      raise e, "Error processing dsl #{dsl_name} for class #{class_name}: #{e.message}", e.backtrace
     end
 
     # Returns an array of all executions for a given class.

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

@@ -6,9 +6,6 @@ module DSLCompose
       class ForDSLParser
         class ForMethodParser
           class AllBlockParametersMustBeKeywordParametersError < StandardError
-            def message
-              "All block parameters must be keyword parameters, i.e. `for_children_of FooClass do |base_class:|`"
-            end
           end
 
           class NoBlockProvided < StandardError
@@ -18,9 +15,6 @@ module DSLCompose
           end
 
           class MethodNamesShouldBeSymbolsError < StandardError
-            def message
-              "Method names must be provided with a symbol or array of symbols"
-            end
           end
 
           # This class will yield to the provided block once for each time a method
@@ -43,7 +37,7 @@ module DSLCompose
             if block.parameters.any?
               # all parameters must be keyword arguments
               if block.parameters.filter { |p| p.first != :keyreq }.any?
-                raise AllBlockParametersMustBeKeywordParametersError
+                raise AllBlockParametersMustBeKeywordParametersError, "All block parameters must be keyword parameters, i.e. `for_children_of FooClass do |base_class:|`"
               end
             end
 
@@ -54,17 +48,17 @@ module DSLCompose
 
             # assert that the provided dsl name is an array
             unless method_names.is_a? Array
-              raise MethodNamesShouldBeSymbolsError
+              raise MethodNamesShouldBeSymbolsError, "Method names `#{method_names}` must be provided with a symbol or array of symbols"
             end
 
             # assert that the provided dsl name is an array of symbols
             unless method_names.all? { |method_name| method_name.is_a? Symbol }
-              raise MethodNamesShouldBeSymbolsError
+              raise MethodNamesShouldBeSymbolsError, "Method names `#{method_names}` must be provided with a symbol or array of symbols"
             end
 
             # assert that the provided method names all exist for the scoped DSL
             unless method_names.all? { |method_name| dsl_execution.dsl.has_dsl_method?(method_name) }
-              raise MethodDoesNotExistError
+              raise MethodDoesNotExistError, "Method names `#{method_names}` must all exist"
             end
 
             # for each provided dsl name, yield to the provided block

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

@@ -5,9 +5,6 @@ module DSLCompose
     class ForChildrenOfParser
       class ForDSLParser
         class AllBlockParametersMustBeKeywordParametersError < StandardError
-          def message
-            "All block parameters must be keyword parameters, i.e. `for_dsl :dsl_name do |dsl_name:|`"
-          end
         end
 
         class NoBlockProvided < StandardError
@@ -17,9 +14,6 @@ module DSLCompose
         end
 
         class DSLNamesShouldBeSymbolsError < StandardError
-          def message
-            "DSL names must be provided with a symbol or array of symbols"
-          end
         end
 
         # This class will yield to the provided block once for each time a DSL
@@ -40,7 +34,7 @@ module DSLCompose
           if block.parameters.any?
             # all parameters must be keyword arguments
             if block.parameters.filter { |p| p.first != :keyreq }.any?
-              raise AllBlockParametersMustBeKeywordParametersError
+              raise AllBlockParametersMustBeKeywordParametersError, "All block parameters must be keyword parameters, i.e. `for_dsl :dsl_name do |dsl_name:|`"
             end
           end
 
@@ -51,17 +45,17 @@ module DSLCompose
 
           # assert that the provided dsl name is an array
           unless dsl_names.is_a? Array
-            raise DSLNamesShouldBeSymbolsError
+            raise DSLNamesShouldBeSymbolsError, "DSL names `#{dsl_names}` must be provided with a symbol or array of symbols"
           end
 
           # assert that the provided dsl name is an array of symbols
           unless dsl_names.all? { |dsl_name| dsl_name.is_a? Symbol }
-            raise DSLNamesShouldBeSymbolsError
+            raise DSLNamesShouldBeSymbolsError, "DSL names `#{dsl_names}` must be provided with a symbol or array of symbols"
           end
 
           # assert that the provided dsl names all exist
           unless dsl_names.all? { |dsl_name| DSLs.class_dsl_exists?(base_class, dsl_name) }
-            raise DSLDoesNotExistError
+            raise DSLDoesNotExistError, "DSLs named `#{dsl_names}` must all exist"
           end
 
           # for each provided dsl name, yield to the provided block

data/lib/dsl_compose/parser/for_children_of_parser.rb

@@ -4,9 +4,6 @@ module DSLCompose
   class Parser
     class ForChildrenOfParser
       class AllBlockParametersMustBeKeywordParametersError < StandardError
-        def message
-          "All block parameters must be keyword parameters, i.e. `for_children_of FooClass do |base_class:|`"
-        end
       end
 
       class ClassDoesNotUseDSLComposeError < StandardError
@@ -16,9 +13,6 @@ module DSLCompose
       end
 
       class NoChildClassError < StandardError
-        def message
-          "No child_class was found, please call this method from within a `for_children_of` block"
-        end
       end
 
       # This class will yield to the provided block for each class which extends the base_class, provided
@@ -26,7 +20,7 @@ module DSLCompose
       def initialize base_class, &block
         # assert the provided class has the DSLCompose::Composer module installed
         unless base_class.respond_to? :dsls
-          raise ClassDoesNotUseDSLComposeError
+          raise ClassDoesNotUseDSLComposeError, base_class
         end
 
         @base_class = base_class
@@ -40,7 +34,7 @@ module DSLCompose
         if block.parameters.any?
           # all parameters must be keyword arguments
           if block.parameters.filter { |p| p.first != :keyreq }.any?
-            raise AllBlockParametersMustBeKeywordParametersError
+            raise AllBlockParametersMustBeKeywordParametersError, "All block parameters must be keyword parameters, i.e. `for_children_of FooClass do |base_class:|`"
           end
         end
 
@@ -78,7 +72,7 @@ module DSLCompose
         child_class = @child_class
 
         unless child_class
-          raise NoChildClassError
+          raise NoChildClassError, "No child_class was found, please call this method from within a `for_children_of` block"
         end
 
         ForDSLParser.new(@base_class, child_class, dsl_names, &block)

data/lib/dsl_compose/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dsl_compose
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Craig Ulliott