dsl_compose 1.6.0 → 1.8.0

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.8.0"
 end

data/lib/dsl_compose.rb

@@ -3,6 +3,7 @@
 require "dsl_compose/version"
 
 require "dsl_compose/dsl/arguments/argument/equal_to_validation"
+require "dsl_compose/dsl/arguments/argument/end_with_validation"
 require "dsl_compose/dsl/arguments/argument/format_validation"
 require "dsl_compose/dsl/arguments/argument/greater_than_or_equal_to_validation"
 require "dsl_compose/dsl/arguments/argument/greater_than_validation"
@@ -10,7 +11,10 @@ require "dsl_compose/dsl/arguments/argument/in_validation"
 require "dsl_compose/dsl/arguments/argument/length_validation"
 require "dsl_compose/dsl/arguments/argument/less_than_or_equal_to_validation"
 require "dsl_compose/dsl/arguments/argument/less_than_validation"
+require "dsl_compose/dsl/arguments/argument/not_end_with_validation"
 require "dsl_compose/dsl/arguments/argument/not_in_validation"
+require "dsl_compose/dsl/arguments/argument/not_start_with_validation"
+require "dsl_compose/dsl/arguments/argument/start_with_validation"
 
 require "dsl_compose/dsl/arguments/argument/interpreter"
 require "dsl_compose/dsl/arguments/argument"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_compose
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-11 00:00:00.000000000 Z
 dependencies: []
 description: Ruby gem to add dynamic DSLs to classes. DSLs are added to classes by
   including the DSLCompose module, and then calling the add_dsl singleton method within
@@ -28,6 +28,7 @@ files:
 - lib/dsl_compose/dsl.rb
 - lib/dsl_compose/dsl/arguments.rb
 - lib/dsl_compose/dsl/arguments/argument.rb
+- lib/dsl_compose/dsl/arguments/argument/end_with_validation.rb
 - lib/dsl_compose/dsl/arguments/argument/equal_to_validation.rb
 - lib/dsl_compose/dsl/arguments/argument/format_validation.rb
 - lib/dsl_compose/dsl/arguments/argument/greater_than_or_equal_to_validation.rb
@@ -37,7 +38,10 @@ files:
 - lib/dsl_compose/dsl/arguments/argument/length_validation.rb
 - lib/dsl_compose/dsl/arguments/argument/less_than_or_equal_to_validation.rb
 - lib/dsl_compose/dsl/arguments/argument/less_than_validation.rb
+- lib/dsl_compose/dsl/arguments/argument/not_end_with_validation.rb
 - lib/dsl_compose/dsl/arguments/argument/not_in_validation.rb
+- lib/dsl_compose/dsl/arguments/argument/not_start_with_validation.rb
+- lib/dsl_compose/dsl/arguments/argument/start_with_validation.rb
 - lib/dsl_compose/dsl/dsl_method.rb
 - lib/dsl_compose/dsl/dsl_method/interpreter.rb
 - lib/dsl_compose/dsl/interpreter.rb