dsl_compose 2.8.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6fea0a926ea88fad5e75633a95629a75105580958b512baae3362c47aa2384c
-  data.tar.gz: '03486a86365c848b0815d768eb7de00478bebeb8b87d9412a4b06db67857ebcd'
+  metadata.gz: f1a63126e260fbca1433946b983adcc053c1d457f0356114bd8a8a07cd347399
+  data.tar.gz: 633636a2d3935493452b3b594bb87f27cba96bfe383be8d3948905a1c56b26a9
 SHA512:
-  metadata.gz: 550d159aca95511d2409fb085ba865f9230ac67fb29ddece4e2f7bbfcf054033e8ce598d6f2ff00d088c27a266c14fdaf1f4405808a6a99fe7ed6888bfeef6a8
-  data.tar.gz: 69c5444f0064dbe31a3da9be2a0712fc419758d3ca661ecf70a22429e80d4581e451a1840a28a7fc2d44902b183d20dc9069036d0f062ad78465de6c58a86a4c
+  metadata.gz: de52f063d8fd04e95e8c389cd91f95c6fc2fb7e346a56fae7ee5f433385c52499412a37d7197c9f60c2886f4f7f194c57b0f0b93232a6993c1fe7c8f4e0fbe61
+  data.tar.gz: 6e66853fb176c9de01f637e83f83536a3a59872175a9ce13a1aeafcfd004f012d27dc6b83068db6fb8a72a69b76d2a1fed6bf93a9fb9cd4a3d8f7129912ad868

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [2.10.0](https://github.com/craigulliott/dsl_compose/compare/v2.9.0...v2.10.0) (2023-09-02)
+
+
+### Features
+
+* adding a `has_argument?` method to the DSL reader base class ([4a5db6a](https://github.com/craigulliott/dsl_compose/commit/4a5db6ab258283960fc909bdf46c75837475aa59))
+
+## [2.9.0](https://github.com/craigulliott/dsl_compose/compare/v2.8.0...v2.9.0) (2023-08-31)
+
+
+### Features
+
+* adding rbs signatures to built gem so they are available in other projects ([1733e11](https://github.com/craigulliott/dsl_compose/commit/1733e1103921fd6724cf994ce430ef0f2a1f7806))
+
+
+### Bug Fixes
+
+* improving the rerun_all method so that the list of parsers to rerun does not depend on a parser having previously executed it's for_children_of method ([679d896](https://github.com/craigulliott/dsl_compose/commit/679d896c3efb2c5808b99f7fb996ca66f17d541d))
+
 ## [2.8.0](https://github.com/craigulliott/dsl_compose/compare/v2.7.0...v2.8.0) (2023-08-31)
 
 

data/lib/dsl_compose/parser.rb

@@ -32,17 +32,12 @@ module DSLCompose
     # children of their own)
     def self.for_children_of base_class, final_children_only: false, rerun: false, &block
       unless rerun
-        run = {
+        @runs ||= []
+        @runs << {
           base_class: base_class,
           final_children_only: final_children_only,
           block: block
         }
-
-        @@all_runs ||= []
-        @@all_runs << run
-
-        @runs ||= []
-        @runs << run
       end
 
       # we parse the provided block in the context of the ForChildrenOfParser class
@@ -59,7 +54,7 @@ module DSLCompose
     end
 
     # this method is used to rerun the parser, this is most useful from within a test suite
-    # when you are testing the parser itself
+    # when you are testing the parser or the effects of running the parser
     def self.rerun
       # rerun each parser for this specific class
       @runs&.each do |run|
@@ -70,15 +65,17 @@ module DSLCompose
       end
     end
 
+    # so we know which parsers have run, and in which order
+    def self.inherited subclass
+      @@all_parser_classes ||= []
+      @@all_parser_classes << subclass
+    end
+
     # this method is used to rerun all of the parsers, this is most useful from within a test suite
-    # when you are testing the parser itself
+    # when you are testing the parser or the effects of running the parser
     def self.rerun_all
-      # rerun each parser for all classes (call this method directly on the parser object `DSLCompose::Parser.rerun_all`)
-      @all_runs&.each do |run|
-        base_class = run[:base_class]
-        block = run[:block]
-        final_children_only = run[:final_children_only]
-        for_children_of base_class, rerun: true, final_children_only: final_children_only, &block
+      @@all_parser_classes.each do |parser_class|
+        parser_class.rerun
       end
     end
   end

data/lib/dsl_compose/reader/execution_reader/arguments_reader.rb

@@ -27,6 +27,11 @@ module DSLCompose
           @argument_values.arguments[argument.name]
         end
 
+        # returns true if the DSL has an argument with the provided name
+        def has_argument? argument_name
+          @arguments.has_argument? argument_name
+        end
+
         def respond_to_missing? method_name
           @arguments.has_argument? method_name
         end

data/lib/dsl_compose/version.rb

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

data/sig/dsl_compose/class_coerce.rbs

@@ -0,0 +1,14 @@
+# Classes
+module DSLCompose
+  class ClassCoerce
+    @class_name: String
+
+    def initialize: (String class_name) -> void
+    def to_class: -> untyped
+
+
+    class UnexpectedClassNameError < StandardError
+    end
+
+  end
+end

data/sig/dsl_compose/composer.rbs

@@ -0,0 +1,20 @@
+# Classes
+module DSLCompose
+  module Composer
+    def self.included: (untyped klass) -> untyped
+
+    def self.get_dsl: (Symbol name) -> DSL
+
+    def self.define_dsl: (Symbol name) -> void
+
+    class ComposerAlreadyInstalledError < StandardError
+    end
+
+    class MethodAlreadyExistsWithThisDSLNameError < StandardError
+    end
+
+    class GetDSLExecutionResultsMethodAlreadyExistsError < StandardError
+    end
+
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/end_with_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class EndWithValidation
+          @values: Array[Symbol]
+
+          def initialize: (Symbol | Array[Symbol]) -> void
+          def validate!: (Symbol | String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/equal_to_validation.rbs

@@ -0,0 +1,20 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class EqualToValidation
+          @value: Numeric | String | Symbol | bool
+
+          def initialize: (Numeric | String | Symbol | bool value) -> void
+          def validate!: (Numeric | String | Symbol | bool value) -> true
+
+
+          class ValidationFailedError < StandardError
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/format_validation.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class FormatValidation
+          @regex: Regexp
+
+          def initialize: (Regexp regex) -> void
+          def validate!: (String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/greater_than_or_equal_to_validation.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class GreaterThanOrEqualToValidation
+          @value: Numeric
+
+          def initialize: (Numeric value) -> void
+          def validate!: (Numeric value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/greater_than_validation.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class GreaterThanValidation
+          @value: Numeric
+
+          def initialize: (Numeric value) -> void
+          def validate!: (Numeric value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/in_validation.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class InValidation
+          @values: Array[Numeric | Symbol | String]
+
+          def initialize: (Array[Numeric | Symbol | String] values) -> void
+          def validate!: (Numeric | Symbol | String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/interpreter.rbs

@@ -0,0 +1,32 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class Interpreter
+          @argument: Argument
+
+          def initialize: (Argument argument) -> void
+          def instance_eval: () -> void
+
+          private
+          def description: (String description) -> void
+          def validate_greater_than: (Numeric value) -> void
+          def validate_greater_than_or_equal_to: (Numeric value) -> void
+          def validate_less_than: (Numeric value) -> void
+          def validate_less_than_or_equal_to: (Numeric value) -> void
+          def validate_equal_to: (Numeric value) -> void
+          def validate_length: (?minimum: Numeric?, ?maximum: Numeric?, ?is: Numeric?) -> void
+          def validate_not_in: ([Numeric | Symbol | String] values) -> void
+          def validate_in: ([Numeric | Symbol | String] values) -> void
+          def validate_end_with: (Symbol | Array[Symbol] value) -> void
+          def validate_not_end_with: (Symbol | Array[Symbol] value) -> void
+          def validate_start_with: (Symbol | Array[Symbol] value) -> void
+          def validate_not_start_with: (Symbol | Array[Symbol] value) -> void
+          def validate_format: (Regexp regex) -> void
+          def validate_is_a: (String class_name) -> void
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/is_a_validation.rbs

@@ -0,0 +1,18 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class IsAValidation
+          @value: Object
+
+          def initialize: (Object value) -> void
+          def validate!: (untyped value) -> true
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/length_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class LengthValidation
+          @maximum: nil | Numeric
+          @minimum: nil | Numeric
+          @is: nil | Numeric
+
+          def initialize: (?maximum: nil | Numeric, ?minimum: nil | Numeric, ?is: nil | Numeric) -> void
+          def validate!: (String | Symbol value) -> true
+
+          class ValidationFailedError < StandardError
+          end
+
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/less_than_or_equal_to_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class LessThanOrEqualToValidation
+          @value: Numeric
+
+          def initialize: (Numeric value) -> void
+          def validate!: (Numeric value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/less_than_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class LessThanValidation
+          @value: Numeric
+
+          def initialize: (Numeric value) -> void
+          def validate!: (Numeric value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/not_end_with_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class NotEndWithValidation
+          @values: Array[Symbol]
+
+          def initialize: (Symbol | Array[Symbol]) -> void
+          def validate!: (Symbol | String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/not_in_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class NotInValidation
+          @values: Array[Numeric | Symbol | String]
+
+          def initialize: (Array[Numeric | Symbol | String] values) -> void
+          def validate!: (Numeric | Symbol | String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/not_start_with_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class NotStartWithValidation
+          @values: Array[Symbol]
+
+          def initialize: (Symbol | Array[Symbol]) -> void
+          def validate!: (Symbol | String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument/start_with_validation.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        class StartWithValidation
+          @values: Array[Symbol]
+
+          def initialize: (Symbol | Array[Symbol]) -> void
+          def validate!: (Symbol | String value) -> true
+
+          class InvalidValueError < StandardError
+          end
+
+          class ValidationFailedError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments/argument.rbs

@@ -0,0 +1,78 @@
+type argument_type = :integer | :string | :boolean | :float | :array | :symbol | :class | :object
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      class Argument
+        RESERVED_ARGUMENT_NAMES: Array[Symbol]
+
+        attr_reader name: Symbol
+        attr_reader type: argument_type
+        attr_reader required: bool
+        attr_reader array: bool
+        attr_reader description: String
+
+        attr_reader greater_than_validation: GreaterThanValidation
+        attr_reader greater_than_or_equal_to_validation: GreaterThanOrEqualToValidation
+        attr_reader less_than_validation: LessThanValidation
+        attr_reader less_than_or_equal_to_validation: LessThanOrEqualToValidation
+        attr_reader format_validation: FormatValidation
+        attr_reader equal_to_validation: EqualToValidation
+        attr_reader in_validation: InValidation
+        attr_reader not_in_validation: NotInValidation
+        attr_reader end_with_validation: EndWithValidation
+        attr_reader not_end_with_validation: NotEndWithValidation
+        attr_reader start_with_validation: StartWithValidation
+        attr_reader not_start_with_validation: NotStartWithValidation
+        attr_reader length_validation: LengthValidation
+        attr_reader is_a_validation: IsAValidation
+
+        def initialize: (Symbol name, bool required, argument_type `type`, ?array: bool) -> void
+        def set_description: (String description) -> void
+        def has_description?: () -> bool
+        def required?: -> bool
+        def optional?: -> bool
+
+        def validate_greater_than: (Numeric value) -> void
+        def validate_greater_than_or_equal_to: (Numeric value) -> void
+        def validate_less_than: (Numeric value) -> void
+        def validate_less_than_or_equal_to: (Numeric value) -> void
+        def validate_format: (Regexp regexp) -> void
+        def validate_equal_to: (Numeric | Symbol | String value) -> void
+        def validate_in: (Array[Numeric | Symbol | String] values) -> void
+        def validate_not_in: (Array[Numeric | Symbol | String] values) -> void
+        def validate_end_with: (Symbol | Array[Symbol] value) -> void
+        def validate_not_end_with: (Symbol | Array[Symbol] value) -> void
+        def validate_start_with: (Symbol | Array[Symbol] value) -> void
+        def validate_not_start_with: (Symbol | Array[Symbol] value) -> void
+        def validate_length: (?maximum: nil | Numeric, ?minimum: nil | Numeric, ?is: nil | Numeric) -> void
+        def validate_is_a: (String class_name) -> void
+
+        class ValidationInvalidArgumentError < StandardError
+        end
+
+        class ValidationIncompatibleError < StandardError
+          def message: -> untyped
+        end
+
+        class ValidationAlreadyExistsError < StandardError
+        end
+
+        class InvalidTypeError < StandardError
+        end
+
+        class ArgumentNameReservedError < StandardError
+        end
+
+        class InvalidNameError < StandardError
+        end
+
+        class InvalidDescriptionError < StandardError
+        end
+
+        class DescriptionAlreadyExistsError < StandardError
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/arguments.rbs

@@ -0,0 +1,33 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Arguments
+      @arguments: Hash[Symbol, Argument]
+
+      def initialize: -> void
+      def arguments: -> Array[Argument]
+      def optional_arguments: -> Array[Argument]
+      def required_arguments: -> Array[Argument]
+      def argument: (Symbol name) -> Argument
+      def optional_argument: (Symbol name) -> Argument
+      def required_argument: (Symbol name) -> Argument
+      def has_argument?: (Symbol name) -> bool
+      def add_argument: (Symbol name, bool required, argument_type `type`, ?array: bool) -> Argument
+
+      class ArgumentDoesNotExistError < StandardError
+        end
+
+      class ArgumentOrderingError < StandardError
+        end
+
+      class ArgumentAlreadyExistsError < StandardError
+        end
+
+      class RequestedOptionalArgumentIsRequiredError < StandardError
+        end
+
+      class RequestedRequiredArgumentIsOptionalError < StandardError
+        end
+    end
+  end
+end

data/sig/dsl_compose/dsl/dsl_method/interpreter.rbs

@@ -0,0 +1,18 @@
+# Classes
+module DSLCompose
+  class DSL
+    class DSLMethod
+      class Interpreter
+        @dsl_method: DSLMethod
+
+        def initialize: (DSLMethod dsl_method) -> void
+        def instance_eval: () -> void
+
+        private
+        def description: (String description) -> void
+        def optional: (Symbol name, argument_type `type`, ?array: bool) -> void
+        def requires: (Symbol name, argument_type `type`, ?array: bool) -> void
+      end
+    end
+  end
+end

data/sig/dsl_compose/dsl/dsl_method.rbs

@@ -0,0 +1,47 @@
+# Classes
+module DSLCompose
+  class DSL
+    class DSLMethod
+
+      attr_reader name: Symbol
+      attr_reader unique: bool
+      attr_reader required: bool
+      attr_reader description: String
+      attr_reader arguments: Arguments
+
+      def initialize: (Symbol name, bool unique, bool required) -> void
+      def set_description: (String description) -> void
+      def has_description?: -> bool
+      def unique?: -> bool
+      def required?: -> bool
+      def optional?: -> bool
+
+      class ArgumentDoesNotExistError < StandardError
+        end
+
+      class InvalidNameError < StandardError
+        end
+
+      class MethodNameIsReservedError < StandardError
+        end
+
+      class InvalidDescriptionError < StandardError
+        end
+
+      class DescriptionAlreadyExistsError < StandardError
+        end
+
+      class ArgumentOrderingError < StandardError
+        end
+
+      class ArgumentAlreadyExistsError < StandardError
+        end
+
+      class RequestedOptionalArgumentIsRequiredError < StandardError
+        end
+
+      class RequestedRequiredArgumentIsOptionalError < StandardError
+        end
+    end
+  end
+end

data/sig/dsl_compose/dsl/interpreter.rbs

@@ -0,0 +1,20 @@
+# Classes
+module DSLCompose
+  class DSL
+    class Interpreter
+      @dsl: DSL
+
+      def initialize: (DSL dsl) -> void
+      def instance_eval: () -> void
+
+      private
+      def description: (String description) -> void
+      def namespace: (Symbol namespace) -> void
+      def title: (String title) -> void
+      def add_method: (Symbol name, ?required: nil) -> void
+      def add_unique_method: (Symbol name, ?required: nil) -> void
+      def optional: (Symbol name, argument_type `type`, ?array: bool) -> void
+      def requires: (Symbol name, argument_type `type`, ?array: bool) -> void
+    end
+  end
+end

data/sig/dsl_compose/dsl.rbs

@@ -0,0 +1,57 @@
+# Classes
+module DSLCompose
+  class DSL
+    @dsl_methods: Hash[Symbol, DSLMethod]
+
+    attr_reader name: Symbol
+    attr_reader arguments: Arguments
+    attr_reader klass: Object
+    attr_reader description: String
+    attr_reader namespace: Symbol
+    attr_reader title: String
+    def initialize: (Symbol name, Object klass) -> void
+    def evaluate_configuration_block: () -> void
+    def set_description: (String description) -> String
+    def has_description?: -> bool
+    def set_namespace: (Symbol namespace) -> Symbol
+    def has_namespace?: -> bool
+    def set_title: (String title) -> String
+    def has_title?: -> bool
+    def add_method: (Symbol name, bool unique, bool required) -> DSLMethod
+    def dsl_methods: -> Array[DSLMethod]
+    def required_dsl_methods: -> Array[DSLMethod]
+    def optional_dsl_methods: -> Array[DSLMethod]
+    def dsl_method: (Symbol name) -> DSLMethod
+    def has_dsl_method?: (Symbol name) -> bool
+
+    class MethodDoesNotExistError < StandardError
+    end
+
+    class MethodAlreadyExistsError < StandardError
+    end
+
+    class InvalidNameError < StandardError
+    end
+
+    class NoBlockProvidedError < StandardError
+    end
+
+    class InvalidDescriptionError < StandardError
+    end
+
+    class DescriptionAlreadyExistsError < StandardError
+    end
+
+    class InvalidNamespaceError < StandardError
+    end
+
+    class NamespaceAlreadyExistsError < StandardError
+    end
+
+    class InvalidTitleError < StandardError
+    end
+
+    class TitleAlreadyExistsError < StandardError
+    end
+  end
+end

data/sig/dsl_compose/dsls.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  module DSLs
+    self.@dsls: Hash[Object, Hash[Symbol, DSL]]
+
+    def self.create_dsl: (Object klass, Symbol name) -> DSL
+    def self.class_dsl_exists?: (Object klass, Symbol name) -> bool
+    def self.dsls: -> Hash[Object, Hash[Symbol, DSL]]
+    def self.class_dsls: (Object klass) -> Array[DSL]
+    def self.class_dsl: (Object klass, Symbol name) -> DSL
+    def self.reset: -> void
+
+    class ClassDSLDefinitionDoesNotExistError < StandardError
+    end
+
+    class DSLAlreadyExistsError < StandardError
+    end
+
+    class NoDSLDefinitionsForClassError < StandardError
+    end
+  end
+end

data/sig/dsl_compose/interpreter/execution/arguments.rbs

@@ -0,0 +1,28 @@
+# Classes
+module DSLCompose
+  class Interpreter
+    class Execution
+      class Arguments
+        attr_reader arguments: Hash[untyped, untyped]
+        def initialize: (untyped arguments, *untyped args) -> void
+        def to_h: -> Hash[untyped, untyped]
+
+        class MissingRequiredArgumentsError < StandardError
+          def initialize: (untyped required_count, untyped provided_count) -> void
+        end
+
+        class TooManyArgumentsError < StandardError
+        end
+
+        class OptionalArgumentsShouldBeHashError < StandardError
+        end
+
+        class InvalidArgumentTypeError < StandardError
+        end
+
+        class ArrayNotValidError < StandardError
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/interpreter/execution/method_calls/method_call.rbs

@@ -0,0 +1,26 @@
+# Classes
+module DSLCompose
+  class Interpreter
+    class Execution
+      class MethodCalls
+        class MethodCall
+          class InvalidDescriptionError < StandardError
+          end
+
+          @method_call: MethodCall
+          @parser_usage_notes: Array[String]
+
+          attr_reader dsl_method: DSL::DSLMethod
+          attr_reader arguments: Arguments
+
+          def initialize: (DSL::DSLMethod dsl_method, *untyped args) -> void
+          def method_name: -> Symbol
+          def add_parser_usage_note: (String note) -> void
+          def parser_usage_notes: () -> Array[String]
+
+          def to_h: -> Hash[untyped, untyped]
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/interpreter/execution/method_calls.rbs

@@ -0,0 +1,16 @@
+# Classes
+module DSLCompose
+  class Interpreter
+    class Execution
+      class MethodCalls
+        @method_calls: Array[MethodCall]
+
+        def initialize: -> void
+        def method_calls: () -> Array[MethodCall]
+        def method_called?: (Symbol method_name) -> bool
+        def method_calls_by_name: (Symbol method_name) -> Array[MethodCall]
+        def add_method_call: (DSL::DSLMethod dsl_method, *untyped args) -> MethodCall
+      end
+    end
+  end
+end

data/sig/dsl_compose/interpreter/execution.rbs

@@ -0,0 +1,28 @@
+# Classes
+module DSLCompose
+  class Interpreter
+    class Execution
+      @parser_usage_notes: Array[String]
+
+      attr_reader dsl: DSL
+      attr_reader klass: Object
+      attr_reader method_calls: MethodCalls
+      attr_reader arguments: Arguments
+
+      def initialize: (Object klass, DSL dsl, *untyped args) -> void
+      def instance_eval: () -> void
+      def add_parser_usage_note: (String note) -> void
+      def parser_usage_notes: () -> Array[String]
+
+      private
+      def method_missing: (Symbol method_name, *untyped args) -> untyped
+      def respond_to_missing?: (Symbol method_name, *untyped args) -> untyped
+
+      class MethodIsUniqueError < StandardError
+      end
+
+      class RequiredMethodNotCalledError < StandardError
+      end
+    end
+  end
+end

data/sig/dsl_compose/interpreter.rbs

@@ -0,0 +1,21 @@
+# Classes
+module DSLCompose
+  class Interpreter
+    @parser_usage_notes: Hash[singleton(Object), Array[String]]
+    attr_reader executions: Array[Execution]
+    def initialize: -> void
+    def execute_dsl: (untyped klass, DSL dsl, *untyped args) -> Execution
+    def class_executions: (singleton(Object) klass) -> Array[Execution]
+    def dsl_executions: (Symbol dsl_name) -> Array[Execution]
+    def to_h: (Symbol dsl_name) -> Hash[Symbol, Hash[Symbol, Array[Hash[Symbol, Symbol]]]]
+    def executions_by_class: () -> Hash[Symbol, Hash[Symbol, Array[Hash[Symbol, Symbol]]]]
+    def add_parser_usage_note: (singleton(Object) klass, String note) -> void
+    def parser_usage_notes: (singleton(Object) klass) -> Array[String]
+
+    class InvalidDescriptionError < StandardError
+    end
+
+    class DSLExecutionNotFoundError < StandardError
+    end
+  end
+end

data/sig/dsl_compose/parser/block_arguments.rbs

@@ -0,0 +1,8 @@
+# Classes
+module DSLCompose
+  class Parser
+    class BlockArguments
+      def self.accepts_argument?: (Symbol arg_name) -> bool
+    end
+  end
+end

data/sig/dsl_compose/parser/for_children_of_parser/descendents.rbs

@@ -0,0 +1,17 @@
+# Classes
+module DSLCompose
+  class Parser
+    class ForChildrenOfParser
+      class Descendents
+        @base_class: singleton(Object)
+        @final_children_only: bool
+
+        def initialize: (singleton(Object) base_class, bool final_children_only) -> void
+        def classes: -> Array[singleton(Object)]
+
+        private
+        def has_descendents: (singleton(Object) base_class) -> bool
+      end
+    end
+  end
+end

data/sig/dsl_compose/parser/for_children_of_parser/for_dsl_parser/for_method_parser.rbs

@@ -0,0 +1,37 @@
+# Classes
+module DSLCompose
+  class Parser
+    class ForChildrenOfParser
+      class ForDSLParser
+        class ForMethodParser
+          @base_class: singleton(Object)
+          @child_class: singleton(Object)
+          @dsl_execution: Interpreter::Execution
+          @method_names: Array[Symbol]
+          @method_name: Symbol
+          @method_call: Interpreter::Execution::MethodCalls::MethodCall
+
+          def initialize: (singleton(Object) base_class, singleton(Object) child_class, Interpreter::Execution dsl_execution, Array[Symbol] method_names) -> void
+
+          # overriding this method because steep doesn't
+          # correctly infer that a block is being passed to this method
+          def instance_exec: (
+            ::Hash[untyped, untyped] args
+          ) -> void
+
+          class AllBlockParametersMustBeKeywordParametersError < StandardError
+          end
+
+          class NoBlockProvided < StandardError
+          end
+
+          class MethodDoesNotExistError < StandardError
+          end
+
+          class MethodNamesShouldBeSymbolsError < StandardError
+          end
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/parser/for_children_of_parser/for_dsl_parser.rbs

@@ -0,0 +1,36 @@
+# Classes
+module DSLCompose
+  class Parser
+    class ForChildrenOfParser
+      class ForDSLParser
+        @base_class: singleton(Object)
+        @child_class: singleton(Object)
+        @dsl_names: Array[Symbol]
+        @dsl_execution: Interpreter::Execution
+
+        def initialize: (singleton(Object) base_class, singleton(Object) child_class, Array[Symbol] dsl_names, bool on_current_class, bool on_ancestor_class) -> void
+
+        # overriding this method because steep doesn't
+        # correctly infer that a block is being passed to this method
+        def instance_exec: (
+          ::Hash[untyped, untyped] args
+        ) -> void
+
+        private
+        def for_method: (Array[Symbol] method_names) -> void
+
+        class AllBlockParametersMustBeKeywordParametersError < StandardError
+        end
+
+        class NoBlockProvided < StandardError
+        end
+
+        class DSLDoesNotExistError < StandardError
+        end
+
+        class DSLNamesShouldBeSymbolsError < StandardError
+        end
+      end
+    end
+  end
+end

data/sig/dsl_compose/parser/for_children_of_parser.rbs

@@ -0,0 +1,32 @@
+# Classes
+module DSLCompose
+  class Parser
+    class ForChildrenOfParser
+      @base_class: singleton(Object)
+      @child_class: singleton(Object)
+
+      def initialize: (singleton(Object) base_class, bool final_children_only) -> void
+
+      # overriding this method because steep doesn't
+      # correctly infer that a block is being passed to this method
+      def instance_exec: (
+        ::Hash[untyped, untyped] args
+      ) -> void
+
+      private
+      def for_dsl: (Array[Symbol] dsl_names, ?on_current_class: bool, ?on_ancestor_class: bool) -> untyped
+
+      class AllBlockParametersMustBeKeywordParametersError < StandardError
+        end
+
+      class ClassDoesNotUseDSLComposeError < StandardError
+      end
+
+      class NoBlockProvided < StandardError
+      end
+
+      class NoChildClassError < StandardError
+        end
+    end
+  end
+end

data/sig/dsl_compose/parser.rbs

@@ -0,0 +1,12 @@
+# Classes
+module DSLCompose
+  class Parser
+    self.@runs: untyped
+
+    def initialize: -> void
+    def self.for_children_of: (singleton(Object) base_class, ?final_children_only: bool, ?rerun: bool) -> void
+
+    class NotInitializable < StandardError
+    end
+  end
+end

data/sig/dsl_compose/reader/execution_reader/arguments_reader.rbs

@@ -0,0 +1,16 @@
+# Classes
+module DSLCompose
+  class Reader
+    class ExecutionReader
+      class ArgumentsReader
+        @arguments: DSL::Arguments
+        @argument_values: Interpreter::Execution::Arguments
+
+        def initialize: (DSL::Arguments arguments, Interpreter::Execution::Arguments argument_values) -> void
+        def method_missing: (Symbol method_name) -> (ArgumentsReader | nil)
+        def has_argument?: (Symbol method_name) -> bool
+        def respond_to_missing?: (Symbol method_name) -> bool
+      end
+    end
+  end
+end

data/sig/dsl_compose/reader/execution_reader.rbs

@@ -0,0 +1,17 @@
+# Classes
+module DSLCompose
+  class Reader
+    class ExecutionReader
+      @execution: Interpreter::Execution
+
+      def initialize: (Interpreter::Execution execution) -> void
+      def arguments: -> ArgumentsReader
+      def method_called?: (Symbol method_name) -> bool
+      def method_missing: (Symbol method_name) -> (nil | ArgumentsReader | Array[ArgumentsReader])
+      def respond_to_missing?: (Symbol method_name) -> bool
+
+      class InvalidExecution < StandardError
+      end
+    end
+  end
+end

data/sig/dsl_compose/reader.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  class Reader
+    @klass: Class
+    @dsl_name: Symbol
+    @dsl: DSL
+    @dsl_defining_class: Class
+
+    def initialize: (untyped klass, Symbol dsl_name) -> void
+    def last_execution: -> (ExecutionReader | nil)
+    def last_execution!: -> ExecutionReader
+    def executions: -> Array[ExecutionReader]
+    def ancestor_executions: -> Array[ExecutionReader]
+    def all_executions: -> Array[ExecutionReader]
+    def dsl_used?: -> bool
+    def dsl_used_on_ancestors?: -> bool
+    def dsl_used_on_class_or_ancestors?: -> bool
+
+    class DSLNotFound < StandardError
+    end
+  end
+end

data/sig/dsl_compose/reader_base.rbs

@@ -0,0 +1,17 @@
+# Classes
+module DSLCompose
+  class ReaderBase
+    attr_reader base_class: singleton(Object)
+    attr_reader dsl_name: Symbol
+    attr_reader reader: Reader
+    def initialize: (singleton(Object) base_class) -> void
+
+    private
+    def dsl_name_from_class_name: (singleton(ReaderBase) reader_class) -> Symbol
+    def last_execution: -> (Reader::ExecutionReader | nil)
+    def last_execution!: -> Reader::ExecutionReader
+    def executions: -> Array[Reader::ExecutionReader]
+    def ancestor_executions: -> Array[Reader::ExecutionReader]
+    def all_executions: -> Array[Reader::ExecutionReader]
+  end
+end

data/sig/dsl_compose/shared_configuration.rbs

@@ -0,0 +1,22 @@
+# Classes
+module DSLCompose
+  module SharedConfiguration
+    self.@shared_configuration: Hash[Symbol, untyped]
+
+    def self.add: (Symbol name) -> void
+    def self.get: (Symbol name) -> untyped
+    def self.clear: -> Hash[Symbol, untyped]
+
+    class SharedConfigurationAlreadyExistsError < StandardError
+    end
+
+    class SharedConfigurationDoesNotExistError < StandardError
+    end
+
+    class InvalidSharedConfigurationNameError < StandardError
+    end
+
+    class NoBlockProvidedError < StandardError
+    end
+  end
+end

data/sig/dsl_compose.rbs

@@ -0,0 +1,4 @@
+module DSLCompose
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_compose
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-31 00:00:00.000000000 Z
+date: 2023-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: class_spec_helper
@@ -79,6 +79,47 @@ files:
 - lib/dsl_compose/reader_base.rb
 - lib/dsl_compose/shared_configuration.rb
 - lib/dsl_compose/version.rb
+- sig/dsl_compose.rbs
+- sig/dsl_compose/class_coerce.rbs
+- sig/dsl_compose/composer.rbs
+- sig/dsl_compose/dsl.rbs
+- sig/dsl_compose/dsl/arguments.rbs
+- sig/dsl_compose/dsl/arguments/argument.rbs
+- sig/dsl_compose/dsl/arguments/argument/end_with_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/equal_to_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/format_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/greater_than_or_equal_to_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/greater_than_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/in_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/interpreter.rbs
+- sig/dsl_compose/dsl/arguments/argument/is_a_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/length_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/less_than_or_equal_to_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/less_than_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/not_end_with_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/not_in_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/not_start_with_validation.rbs
+- sig/dsl_compose/dsl/arguments/argument/start_with_validation.rbs
+- sig/dsl_compose/dsl/dsl_method.rbs
+- sig/dsl_compose/dsl/dsl_method/interpreter.rbs
+- sig/dsl_compose/dsl/interpreter.rbs
+- sig/dsl_compose/dsls.rbs
+- sig/dsl_compose/interpreter.rbs
+- sig/dsl_compose/interpreter/execution.rbs
+- sig/dsl_compose/interpreter/execution/arguments.rbs
+- sig/dsl_compose/interpreter/execution/method_calls.rbs
+- sig/dsl_compose/interpreter/execution/method_calls/method_call.rbs
+- sig/dsl_compose/parser.rbs
+- sig/dsl_compose/parser/block_arguments.rbs
+- sig/dsl_compose/parser/for_children_of_parser.rbs
+- sig/dsl_compose/parser/for_children_of_parser/descendents.rbs
+- sig/dsl_compose/parser/for_children_of_parser/for_dsl_parser.rbs
+- sig/dsl_compose/parser/for_children_of_parser/for_dsl_parser/for_method_parser.rbs
+- sig/dsl_compose/reader.rbs
+- sig/dsl_compose/reader/execution_reader.rbs
+- sig/dsl_compose/reader/execution_reader/arguments_reader.rbs
+- sig/dsl_compose/reader_base.rbs
+- sig/dsl_compose/shared_configuration.rbs
 homepage: 
 licenses:
 - MIT