dsl_compose 1.5.0 → 1.7.0

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.
@@ -37,6 +45,13 @@ module DSLCompose
       @executions.filter { |e| e.klass == klass && e.dsl.name == dsl_name }
     end
 
+    # removes all executions from the interpreter, this is primarily used from
+    # within a test suite when dynamically creating classes for tests and then
+    # wanting to clear the interpreter before the next test.
+    def clear
+      @executions = []
+    end
+
     def to_h dsl_name
       h = {}
       dsl_executions(dsl_name).each do |execution|

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.5.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.5.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Craig Ulliott