dsl_compose 1.0.0 → 1.2.0

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class LengthValidation
+          class ValidationFailedError < StandardError
+            def message
+              "The argument is invalid"
+            end
+          end
+
+          def initialize maximum: nil, minimum: nil, is: nil
+            @maximum = maximum
+            @minimum = minimum
+            @is = is
+          end
+
+          def validate! value
+            maximum = @maximum
+            unless maximum.nil?
+              raise ValidationFailedError if value.length > maximum
+            end
+
+            minimum = @minimum
+            unless minimum.nil?
+              raise ValidationFailedError if value.length < minimum
+            end
+
+            is = @is
+            unless is.nil?
+              raise ValidationFailedError if value.length != is
+            end
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class DSL
+    class Arguments
+      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
+            end
+
+            @value = value
+          end
+
+          def validate! value
+            raise ValidationFailedError unless value <= @value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class DSL
+    class Arguments
+      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
+            end
+
+            @value = value
+          end
+
+          def validate! value
+            raise ValidationFailedError unless value < @value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class DSL
+    class Arguments
+      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
+            end
+
+            @values = values
+          end
+
+          def validate! value
+            raise ValidationFailedError if @values.include?(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class DSL
+    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
+
+        # The name of this Argument.
+        attr_reader :name
+        # An arguments type. This determines what kind of value can be passed when calling the
+        # associated DSLMethod.
+        # `type` should be set to either :integer, :boolean, :float, :string or :symbol
+        attr_reader :type
+        # if required, then this Argument must be provided when calling its associated DSLMethod.
+        attr_reader :required
+        # An otional description of this Attribute, if provided then it must be a string.
+        # The description accepts markdown and is used when generating documentation.
+        attr_reader :description
+        # Optional validations that have been applied to this Argument. When the DSL is used
+        # each of these validations will be checked against the value provided to
+        # this Argument.
+        attr_reader :greater_than_validation
+        attr_reader :greater_than_or_equal_to_validation
+        attr_reader :less_than_validation
+        attr_reader :less_than_or_equal_to_validation
+        attr_reader :format_validation
+        attr_reader :equal_to_validation
+        attr_reader :in_validation
+        attr_reader :not_in_validation
+        attr_reader :length_validation
+
+        # Create a new Attribute object.
+        #
+        # `name` must be a symbol.
+        # `required` is a boolean which determines if this Attribute must be provided when
+        # calling its associated DSLMethod.
+        # `type` can be either :integer, :boolean, :float, :string or :symbol
+        # `block` contains the instructions to further configure this Attribute
+        def initialize name, required, type, &block
+          if name.is_a? Symbol
+            @name = name
+          else
+            raise InvalidNameError
+          end
+
+          if type == :integer || type == :boolean || type == :float || type == :string || type == :symbol
+            @type = type
+          else
+            raise InvalidTypeError
+          end
+
+          @required = required ? true : false
+
+          # If a block was provided, then we evaluate it using a seperate
+          # interpreter class. We do this because the interpreter class contains
+          # no other methods or variables, if it was evaluated in the context of
+          # this class then the block would have access to all of the methods defined
+          # in here.
+          if block
+            Interpreter.new(self).instance_eval(&block)
+          end
+        end
+
+        # Set the description for this Argument to the provided value.
+        #
+        # `description` must be a string with a length greater than 0.
+        # The `description` can only be set once per Argument
+        def set_description description
+          unless description.is_a?(String) && description.length > 0
+            raise InvalidDescriptionError
+          end
+
+          if has_description?
+            raise DescriptionAlreadyExistsError
+          end
+
+          @description = description
+        end
+
+        # Returns `true` if this DSL has a description, else false.
+        def has_description?
+          @description.nil? == false
+        end
+
+        # returns true if this DSLMethod is flagged as required, otherwise returns false.
+        def required?
+          @required == true
+        end
+
+        # returns true if this DSLMethod is flagged as optional, otherwise returns false.
+        def optional?
+          @required == false
+        end
+
+        def validate_greater_than value
+          if @greater_than_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless @type == :integer || @type == :float
+            raise ValidationIncompatibleError
+          end
+
+          @greater_than_validation = GreaterThanValidation.new value
+        end
+
+        def validate_greater_than_or_equal_to value
+          if @greater_than_or_equal_to_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless value.is_a?(Numeric)
+            raise ValidationInvalidArgumentError
+          end
+
+          unless @type == :integer || @type == :float
+            raise ValidationIncompatibleError
+          end
+
+          @greater_than_or_equal_to_validation = GreaterThanOrEqualToValidation.new value
+        end
+
+        def validate_less_than value
+          if @less_than_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless value.is_a?(Numeric)
+            raise ValidationInvalidArgumentError
+          end
+
+          unless @type == :integer || @type == :float
+            raise ValidationIncompatibleError
+          end
+
+          @less_than_validation = LessThanValidation.new value
+        end
+
+        def validate_less_than_or_equal_to value
+          if @less_than_or_equal_to_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless value.is_a?(Numeric)
+            raise ValidationInvalidArgumentError
+          end
+
+          unless @type == :integer || @type == :float
+            raise ValidationIncompatibleError
+          end
+
+          @less_than_or_equal_to_validation = LessThanOrEqualToValidation.new value
+        end
+
+        def validate_format regexp
+          if @format_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless regexp.is_a? Regexp
+            raise ValidationInvalidArgumentError
+          end
+
+          unless @type == :string || @type == :symbol
+            raise ValidationIncompatibleError
+          end
+          @format_validation = FormatValidation.new regexp
+        end
+
+        def validate_equal_to value
+          if @equal_to_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless @type == :integer || @type == :float || @type == :string || @type == :symbol || @type == :boolean
+            raise ValidationIncompatibleError
+          end
+
+          @equal_to_validation = EqualToValidation.new value
+        end
+
+        def validate_in values
+          if @in_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless values.is_a? Array
+            raise ValidationInvalidArgumentError
+          end
+
+          unless @type == :integer || @type == :float || @type == :string || @type == :symbol
+            raise ValidationIncompatibleError
+          end
+
+          @in_validation = InValidation.new values
+        end
+
+        def validate_not_in values
+          if @not_in_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless values.is_a? Array
+            raise ValidationInvalidArgumentError
+          end
+
+          unless @type == :integer || @type == :float || @type == :string || @type == :symbol
+            raise ValidationIncompatibleError
+          end
+
+          @not_in_validation = NotInValidation.new values
+        end
+
+        def validate_length maximum: nil, minimum: nil, is: nil
+          if @length_validation
+            raise ValidationAlreadyExistsError
+          end
+
+          unless @type == :string || @type == :symbol
+            raise ValidationIncompatibleError
+          end
+
+          @length_validation = LengthValidation.new(maximum: maximum, minimum: minimum, is: is)
+        end
+
+        # returns true if every provided integer validation also returns true
+        def validate_integer! value
+          (greater_than_validation.nil? || greater_than_validation.validate!(value)) &&
+            (greater_than_or_equal_to_validation.nil? || greater_than_or_equal_to_validation.validate!(value)) &&
+            (less_than_validation.nil? || less_than_validation.validate!(value)) &&
+            (less_than_or_equal_to_validation.nil? || less_than_or_equal_to_validation.validate!(value)) &&
+            (format_validation.nil? || format_validation.validate!(value)) &&
+            (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)) &&
+            (length_validation.nil? || length_validation.validate!(value))
+        end
+
+        # returns true if every provided symbol validation also returns true
+        def validate_symbol! value
+          (format_validation.nil? || format_validation.validate!(value)) &&
+            (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)) &&
+            (length_validation.nil? || length_validation.validate!(value))
+        end
+
+        # returns true if every provided string validation also returns true
+        def validate_string! value
+          (format_validation.nil? || format_validation.validate!(value)) &&
+            (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)) &&
+            (length_validation.nil? || length_validation.validate!(value))
+        end
+
+        # returns true if every provided boolean validation also returns true
+        def validate_boolean! value
+          (equal_to_validation.nil? || equal_to_validation.validate!(value))
+        end
+      end
+    end
+  end
+end

data/lib/dsl_compose/dsl/arguments.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+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
+        @arguments = {}
+      end
+
+      # Returns an array of all this DSLMethods Argument objects.
+      def arguments
+        @arguments.values
+      end
+
+      # Returns an array of only the optional Argument objects on this DSLMethod.
+      def optional_arguments
+        arguments.filter(&:optional?)
+      end
+
+      # Returns an array of only the required Argument objects on this DSLMethod.
+      def required_arguments
+        arguments.filter(&:required?)
+      end
+
+      # returns a specific Argument by it's name, if the Argument does not
+      # exist, then an error is raised
+      def argument name
+        if has_argument? name
+          @arguments[name]
+        else
+          raise ArgumentDoesNotExistError
+        end
+      end
+
+      # returns a specific optional Argument by it's name, if the Argument does not
+      # exist, or if it is required, then an error is raised
+      def optional_argument name
+        arg = argument name
+        if arg.optional?
+          @arguments[name]
+        else
+          raise RequestedOptionalArgumentIsRequiredError
+        end
+      end
+
+      # returns a specific required Argument by it's name, if the Argument does not
+      # exist, or if it is optional, then an error is raised
+      def required_argument name
+        arg = argument name
+        if arg.required?
+          @arguments[name]
+        else
+          raise RequestedRequiredArgumentIsOptionalError
+        end
+      end
+
+      # Returns `true` if an Argument with the provided name exists in this
+      # DSLMethod, otherwise it returns `false`.
+      def has_argument? name
+        @arguments.key? name
+      end
+
+      # Takes a method name, unique flag, required flag, and a block and creates
+      # a new Argument object.
+      #
+      # Argument `name` must be unique within the DSLMethod.
+      # `required` must be a boolean, and determines if this argument will be required
+      # or optional on the method which is exposed in our DSL.
+      def add_argument name, required, type, &block
+        if @arguments.key? name
+          raise ArgumentAlreadyExistsError
+        end
+
+        # required arguments may not come after optional ones
+        if required && optional_arguments.any?
+          raise ArgumentOrderingError
+        end
+
+        @arguments[name] = Argument.new(name, required, type, &block)
+      end
+    end
+  end
+end

data/lib/dsl_compose/dsl/dsl_method/interpreter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class DSL
+    class DSLMethod
+      # This class is reponsible for parsing and executing method definitions
+      # within our internal DSL. These method definitions determine what methods
+      # will be available within our new dynamic DSL.
+      #
+      # This class is instantaited by the DSLCompose::DSL::DSLMethod class and the method definition
+      # part of our internal DSL is evaluated by passing a block to `instance_eval` on this class.
+      #
+      # An example of our internal DSL which includes a complex method definition:
+      #  define_dsl :my_dsl do
+      #    add_method :my_method, required: true do
+      #      description "Description of my method"
+      #      optional :my_optional_argument, :string do
+      #        # ...
+      #      end
+      #      optional :my_optional_arg, String
+      #    end
+      #  end
+      class Interpreter
+        def initialize dsl_method
+          @dsl_method = dsl_method
+        end
+
+        private
+
+        # sets the description of the DSLMethod
+        def description description
+          @dsl_method.set_description description
+        end
+
+        # adds a new optional argument to the DSLMethod
+        #
+        # name must be a symbol
+        # `type` can be either :integer, :boolean, :float, :string or :symbol
+        # `block` contains the argument definition and will be evaluated seperately
+        # by the Argument::Interpreter
+        def optional name, type, &block
+          @dsl_method.arguments.add_argument name, false, type, &block
+        end
+
+        # adds a new required argument to the DSLMethod
+        #
+        # name must be a symbol
+        # `type` can be either :integer, :boolean, :float, :string or :symbol
+        # `block` contains the argument definition and will be evaluated seperately
+        # by the Argument::Interpreter
+        def requires name, type, &block
+          @dsl_method.arguments.add_argument name, true, type, &block
+        end
+      end
+    end
+  end
+end