dsl_compose 1.6.0 → 1.8.0

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 = [
@@ -74,6 +56,10 @@ module DSLCompose
         attr_reader :equal_to_validation
         attr_reader :in_validation
         attr_reader :not_in_validation
+        attr_reader :end_with_validation
+        attr_reader :not_end_with_validation
+        attr_reader :start_with_validation
+        attr_reader :not_start_with_validation
         attr_reader :length_validation
 
         # Create a new Attribute object.
@@ -87,18 +73,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 +97,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 +107,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 +134,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 +150,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 +166,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 +182,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 +198,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 +225,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,27 +241,91 @@ 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
         end
 
+        def validate_end_with value
+          if @end_with_validation
+            raise ValidationAlreadyExistsError, "The validation `end_with` has already been applied to this method option."
+          end
+
+          unless value.is_a? String
+            raise ValidationInvalidArgumentError, value
+          end
+
+          unless @type == :string || @type == :symbol
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
+          end
+
+          @end_with_validation = EndWithValidation.new value
+        end
+
+        def validate_not_end_with value
+          if @not_end_with_validation
+            raise ValidationAlreadyExistsError, "The validation `not_end_with` has already been applied to this method option."
+          end
+
+          unless value.is_a? String
+            raise ValidationInvalidArgumentError, value
+          end
+
+          unless @type == :string || @type == :symbol
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
+          end
+
+          @not_end_with_validation = NotEndWithValidation.new value
+        end
+
+        def validate_start_with value
+          if @start_with_validation
+            raise ValidationAlreadyExistsError, "The validation `start_with` has already been applied to this method option."
+          end
+
+          unless value.is_a? String
+            raise ValidationInvalidArgumentError, value
+          end
+
+          unless @type == :string || @type == :symbol
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
+          end
+
+          @start_with_validation = StartWithValidation.new value
+        end
+
+        def validate_not_start_with value
+          if @not_start_with_validation
+            raise ValidationAlreadyExistsError, "The validation `not_start_with` has already been applied to this method option."
+          end
+
+          unless value.is_a? String
+            raise ValidationInvalidArgumentError, value
+          end
+
+          unless @type == :string || @type == :symbol
+            raise ValidationIncompatibleError, "The validation type #{@type} is not compatible with this argument type"
+          end
+
+          @not_start_with_validation = NotStartWithValidation.new value
+        end
+
         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)
@@ -294,6 +350,10 @@ module DSLCompose
             (equal_to_validation.nil? || equal_to_validation.validate!(value)) &&
             (in_validation.nil? || in_validation.validate!(value)) &&
             (not_in_validation.nil? || not_in_validation.validate!(value)) &&
+            (end_with_validation.nil? || end_with_validation.validate!(value)) &&
+            (not_end_with_validation.nil? || not_end_with_validation.validate!(value)) &&
+            (start_with_validation.nil? || start_with_validation.validate!(value)) &&
+            (not_start_with_validation.nil? || not_start_with_validation.validate!(value)) &&
             (length_validation.nil? || length_validation.validate!(value))
         end
 
@@ -303,6 +363,10 @@ module DSLCompose
             (equal_to_validation.nil? || equal_to_validation.validate!(value)) &&
             (in_validation.nil? || in_validation.validate!(value)) &&
             (not_in_validation.nil? || not_in_validation.validate!(value)) &&
+            (end_with_validation.nil? || end_with_validation.validate!(value)) &&
+            (not_end_with_validation.nil? || not_end_with_validation.validate!(value)) &&
+            (start_with_validation.nil? || start_with_validation.validate!(value)) &&
+            (not_start_with_validation.nil? || not_start_with_validation.validate!(value)) &&
             (length_validation.nil? || length_validation.validate!(value))
         end
 

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