dsl_compose 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8b82032e4bea7187d0dd4a00528472ce1a5b29d4aea64b94d6090b8d013b47b
-  data.tar.gz: 628dda5efddcfdc2b9de8df09245c5af67c233de24dee7654d7266b193b6ef95
+  metadata.gz: 5f215d3a5226d56e6f0f5e62b340e0212607a52c3097228f7fc24ef1f5028a20
+  data.tar.gz: afcf1aa8a22966ca83475f7e0d41780c5e0d44e50b13dc91b33a71011b6d1fc4
 SHA512:
-  metadata.gz: 670c5b83e8d8e3dd986933499d96d92604da968088b31dba613421712beb5ded7c7defec91714a1c23df1a4ba82d55a15a815864376d2ad3970a426232bb42cc
-  data.tar.gz: 48f76cf798a28b60efe4cf1c69d2f21c3594e86de5bbcf674d4a16f68114e76cde998a68c8dfbfbe8860362165bd9af7c37f6be3842e6efbdf9db8568ce72246
+  metadata.gz: fff6880b4032551cabd769fa1c2c6eda13179f4b1e50cb652bdef9a6ecd0055e45994235d0ebb78ee06445086368c304279fa04feddcde41b78e046677aea86c
+  data.tar.gz: 409bae7843d156e2c1e6854ebd87381c2eafcccc8adaf3cd2adfbcc076282efde0d0d12c69fb661f95ac0404c7bfd1b28328bdc6e54f211790fb62571b1dd7a0

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.5.0](https://github.com/craigulliott/dsl_compose/compare/v1.4.0...v1.5.0) (2023-07-07)
+
+
+### Features
+
+* adding a parser method to rerun the parser, this is most useful from within a test suite when you are testing the parser itself ([#15](https://github.com/craigulliott/dsl_compose/issues/15)) ([fe4de0e](https://github.com/craigulliott/dsl_compose/commit/fe4de0e53f78aff34de4ba1c432b10022d2b6ab4))
+
+## [1.4.0](https://github.com/craigulliott/dsl_compose/compare/v1.3.0...v1.4.0) (2023-06-26)
+
+
+### Features
+
+* added a Parser class which can be used to react to any DSLs which have been defined and used ([8d2f16b](https://github.com/craigulliott/dsl_compose/commit/8d2f16b67ae98486a47e6e8d6d6af81be508cb06))
+
 ## [1.3.0](https://github.com/craigulliott/dsl_compose/compare/v1.2.0...v1.3.0) (2023-06-22)
 
 

data/README.md

@@ -11,9 +11,9 @@ Ruby gem to add dynamic DSLs to classes
 
 * Contains a simple internal DSL which is used to declare dynamic DSLs on your classes
 * Takes special care not to pollute the namespace of classes where it is used
-* Use of your declared DSLs is validated at run time
-* Automatically generate documentation and instructions for your DSLs
-* Complete test covereage
+* Use of your declared DSLs is strictly validated at run time
+* Automatically generate documentation for your DSLs
+* Extensive test coverage
 * Very lightweight and no external dependencies
 
 ## Installation
@@ -28,7 +28,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-DSLs are added to classes by including the DSLCompose module, and then calling the add_dsl singleton method within the class or a child class.
+DSLs are defined and added to classes by including the `DSLCompose::Composer` module, and then calling the `define_dsl` singleton method on that class. Those DSLs can then be used on child classes (classes which extend the original class).
 
 ### Defining your DSL
 
@@ -36,11 +36,11 @@ DSLs are added to classes by including the DSLCompose module, and then calling t
 class Foo
   include DSLCompose::Composer
 
-  # Define and name the DSL. Your DSL will available on this
+  # Define and name your DSL. Your DSL will be available on this
   # class and any children of this class.
-  define_dsl :my_dsl do
+  define_dsl :your_dsl do
 
-    # A description of your DSL.
+    # A description of your DSL
     description <<-DESCRIPTION
       Add a description of your DSL here, this description will be
       used when generating the documentation for your DSL.
@@ -48,43 +48,55 @@ class Foo
       You can use **Markdown** in this description.
     DESCRIPTION
 
+    # You can add required or optional arguments to the initial method which is used
+    # to call your dynamic DSL (for optional arguments, use `optional` instead of
+    # `required`)
+    #
+    # Arguments are validated, and their expected type must be defined. Supported
+    # argument types are :integer, :boolean, :float, :string or :symbol
+    requires :first_dsl_argument, :symbol do
+      # You should provide descriptions for your arguments. These descriptions will
+      # be used when generating your documentation. This description supports markdown
+      description "A description of the first argument for this method"
+    end
+
     # Define a method which will be available within your DSL. These
     # methods will be exposed inside your DSL and can be called multiple times.
     add_method :an_optional_method do
       # You should provide descriptions for your methods. These descriptions will
       # be used when generating your documentation. Both of these descriptions
       # accept markdown
-      description "A description of my awesome method"
+      description "A description of your method"
 
-      # add your method argument definition here
+      # Add your method argument definition here
     end
 
-    # Define a required within your DSL. If a class uses your DSL but
-    # does not execute this method then an error will be raised.
+    # Define a required method within your DSL. An error will be raised if a class
+    # uses your DSL but does not execute this method
     add_method :a_required_method, required: true do
-      # add your description and method argument definition here (see below)
+      # Add your description here
+      # Add any method arguments here (more info below about method arguments)
     end
 
     # Define a method which can only be called once within your DSL. These
-    # methods will raise an error of they are called multiple times.
+    # "unique" methods will raise an error of they are called multiple times.
     #
-    # There "unique" methods can be optionally marked as required.
+    # unique methods can be optionally marked as required.
     add_unique_method :an_optional_method do
-      # add your description and method argument definition here (see below)
+      # Add your description and any method arguments here (more info below about method arguments)
     end
 
     # Define a method in your DSL which takes arguments
-    add_method :my_method do
-      # A description of my DSL method
-      description "A description of my DSL method"
+    add_method :your_method do
+      description "A description of your DSL method"
 
       # You can add required arguments to your methods. The order in which you
       # define these arguments determines the order of the arguments in your final DSL.
       #
       # Arguments are validated, and their expected type must be defined. Supported
       # argument types are :integer, :boolean, :float, :string or :symbol
-      requires :my_first_argument, :symbol do
-        # You should provide descriptions for your arguments. These descriptions will
+      requires :first_method_argument, :string do
+        # You should provide descriptions for your arguments too. These descriptions will
         # be used when generating your documentation. This description supports markdown
         description "A description of the first argument for this method"
       end
@@ -92,7 +104,7 @@ class Foo
       # You can also add optional arguments to your DSL methods. All optional
       # arguments must be added after required ones. An error will be raised if
       # you define a required argument after an optional one.
-      optional :an_optional_argument, :integer do
+      optional :optional_argument, :integer do
         description "A description of an optional argument"
 
         # You can add validation to your arguments. A full list is provided later in this document
@@ -112,8 +124,8 @@ Child classes can then use your new DSL
 ```ruby
 class Bar << Foo
 
-  my_dsl do
-    my_method my_first_argument, my_second_argument, optional_arg: optional_arg_value
+  your_dsl :first_dsl_argument, do
+    your_method "first_method_argument", optional_argument: 123
   end
 
 end
@@ -175,6 +187,48 @@ MyClientLibrary.configure do
 end
 ```
 
+## Parsing complicated DSLs
+
+A parser class can be used to process complicated DSLs. In the example below, a base class named SomeBaseClass has DSLs named :dsl1, and :dsl2.
+
+```ruby
+# create your own parser by creating a new class which extends DSLCompose::Parser
+MyParser < DSLCompose::Parser
+  # `for_children_of` will process SomeBaseClass and yield the provided
+  # block once for every class which extends SomeBaseClass and uses at
+  # least one of the DSLs that have been defined on it.
+  for_children_of SomeBaseClass do |child_class:|
+    # `for_dsl` accepts a DSL name or an array of DSL names and will yield
+    # it's provided block once for each time a DSL of that name has been
+    # used on the child_class.
+    #
+    # An error will be raised if any of the provided DSL names does not exist
+    #
+    # You can optionally provide keyword arguments which correspond to any
+    # arguments that were defined for the DSL, if multiple dsl names are provided
+    # then the requested dsl argument must be present on all DSLs otherwise an
+    # error will be raised.
+    for_dsl [:dsl1, :dsl2] do |dsl_name:, a_dsl_argument:|
+      # `for_method` accepts a method name or an array of method names and will
+      # yield it's provided block once for each time a method with this name is
+      # executed within the DSL.
+      #
+      # An error will be raised if any of the provided method names does not exist
+      #
+      # You can optionally provide keyword arguments which correspond to any
+      # arguments that were defined for the DSL method, if multiple method names
+      # are provided then the requested dsl argument must be present on all DSLs
+      # otherwise an error will be raised.
+      for_method :some_method_name do |method_name:, a_method_argument:|
+        # your business logic goes here
+        ...
+      end
+    end
+  end
+end
+```
+
+
 ## Argument validations
 
 The following validations can be added to the arguments of your DSL methods. Validations can be added to both required and optional arguments, and you can add multiple validations to each argument.

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

@@ -40,6 +40,18 @@ module DSLCompose
           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
+
+        RESERVED_ARGUMENT_NAMES = [
+          :child_class,
+          :dsl_name,
+          :method_name
+        ].freeze
+
         # The name of this Argument.
         attr_reader :name
         # An arguments type. This determines what kind of value can be passed when calling the
@@ -73,6 +85,11 @@ module DSLCompose
         # `block` contains the instructions to further configure this Attribute
         def initialize name, required, type, &block
           if name.is_a? Symbol
+
+            if RESERVED_ARGUMENT_NAMES.include? name
+              raise ArgumentNameReservedError
+            end
+
             @name = name
           else
             raise InvalidNameError

data/lib/dsl_compose/interpreter/execution/arguments.rb

@@ -6,13 +6,13 @@ module DSLCompose
       class Arguments
         class MissingRequiredArgumentsError < StandardError
           def initialize required_count, provided_count
-            super "This method requires #{required_count} arguments, but only #{required_count} were provided"
+            super "This requires #{required_count} arguments, but only #{provided_count} were provided"
           end
         end
 
         class TooManyArgumentsError < StandardError
           def message
-            "Too many arguments provided to this method"
+            "Too many arguments provided"
           end
         end
 

data/lib/dsl_compose/interpreter/execution/method_calls.rb

@@ -19,6 +19,10 @@ module DSLCompose
           @method_calls << method_call
           method_call
         end
+
+        def method_calls_by_name method_name
+          @method_calls.filter { |mc| mc.method_name == method_name }
+        end
       end
     end
   end

data/lib/dsl_compose/interpreter.rb

@@ -27,11 +27,16 @@ module DSLCompose
       @executions.filter { |e| e.klass == klass }
     end
 
-    # Returns an array of all executions for a given class.
+    # Returns an array of all executions for a given name.
     def dsl_executions dsl_name
       @executions.filter { |e| e.dsl.name == dsl_name }
     end
 
+    # Returns an array of all executions for a given name and class.
+    def class_dsl_executions klass, dsl_name
+      @executions.filter { |e| e.klass == klass && e.dsl.name == dsl_name }
+    end
+
     def to_h dsl_name
       h = {}
       dsl_executions(dsl_name).each do |execution|

data/lib/dsl_compose/parser/block_arguments.rb

@@ -0,0 +1,9 @@
+module DSLCompose
+  class Parser
+    class BlockArguments
+      def self.accepts_argument? arg_name, &block
+        block.parameters.any? { |type, name| name == arg_name }
+      end
+    end
+  end
+end

data/lib/dsl_compose/parser/for_children_of_parser/for_dsl_parser/for_method_parser.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class Parser
+    class ForChildrenOfParser
+      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
+          end
+
+          class MethodDoesNotExistError < StandardError
+          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
+          # with the provided name is called within a DSL called on the child class.
+          #
+          # base_class and child_class are set from the ForChildrenOfParser
+          # dsl_execution is set from the ForDSLParser
+          def initialize base_class, child_class, dsl_execution, method_names, &block
+            @base_class = base_class
+            @child_class = child_class
+            @dsl_execution = dsl_execution
+            @method_names = method_names
+
+            # assert that a block was provided
+            unless block
+              raise NoBlockProvided
+            end
+
+            # if any arguments were provided, then assert that they are valid
+            if block.parameters.any?
+              # all parameters must be keyword arguments
+              if block.parameters.filter { |p| p.first != :keyreq }.any?
+                raise AllBlockParametersMustBeKeywordParametersError
+              end
+            end
+
+            # if the provided dsl name is a symbol, then convert it to an array
+            if method_names.is_a? Symbol
+              method_names = [method_names]
+            end
+
+            # assert that the provided dsl name is an array
+            unless method_names.is_a? Array
+              raise MethodNamesShouldBeSymbolsError
+            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
+            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
+            end
+
+            # for each provided dsl name, yield to the provided block
+            method_names.each do |method_name|
+              # we only provide the requested arguments to the block, this allows
+              # us to use keyword arguments to force a naming convention on these arguments
+              # and to validate their use
+              args = {}
+              if BlockArguments.accepts_argument?(:method_name, &block)
+                args[:method_name] = method_name
+              end
+
+              # methods can be executed multiple times, so yield once for each method call
+              # add any arguments that were provided to the DSL method
+              dsl_execution.method_calls.method_calls_by_name(method_name).each do |method_call|
+                # add any arguments that were provided to the method call
+                method_call.arguments.arguments.each do |name, value|
+                  if BlockArguments.accepts_argument?(name, &block)
+                    args[name] = value
+                  end
+                end
+
+                # yeild the block in the context of this class
+                instance_exec(**args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsl_compose/parser/for_children_of_parser/for_dsl_parser.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  class Parser
+    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
+        end
+
+        class DSLDoesNotExistError < StandardError
+        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
+        # of the provided name is used by the child class.
+        #
+        # base_class and child_class are set from the ForChildrenOfParser
+        def initialize base_class, child_class, dsl_names, &block
+          @base_class = base_class
+          @child_class = child_class
+          @dsl_names = dsl_names
+
+          # assert that a block was provided
+          unless block
+            raise NoBlockProvided
+          end
+
+          # if any arguments were provided, then assert that they are valid
+          if block.parameters.any?
+            # all parameters must be keyword arguments
+            if block.parameters.filter { |p| p.first != :keyreq }.any?
+              raise AllBlockParametersMustBeKeywordParametersError
+            end
+          end
+
+          # if the provided dsl name is a symbol, then convert it to an array
+          if dsl_names.is_a? Symbol
+            dsl_names = [dsl_names]
+          end
+
+          # assert that the provided dsl name is an array
+          unless dsl_names.is_a? Array
+            raise DSLNamesShouldBeSymbolsError
+          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
+          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
+          end
+
+          # for each provided dsl name, yield to the provided block
+          dsl_names.each do |dsl_name|
+            # a dsl can be execued multiple times on a class, so we find all of the executions
+            # here and then yield the block once for each execution
+            base_class.dsls.class_dsl_executions(child_class, dsl_name).each do |dsl_execution|
+              # we only provide the requested arguments to the block, this allows
+              # us to use keyword arguments to force a naming convention on these arguments
+              # and to validate their use
+              args = {}
+              if BlockArguments.accepts_argument?(:dsl_name, &block)
+                args[:dsl_name] = dsl_execution.dsl.name
+              end
+              # add any arguments that were provided to the DSL
+              dsl_execution.arguments.arguments.each do |name, value|
+                if BlockArguments.accepts_argument?(name, &block)
+                  args[name] = value
+                end
+              end
+              # set the dsl_execution in an instance variable so that method calls to `for_method`
+              # from within the block will have access to it
+              @dsl_execution = dsl_execution
+              # yield the block in the context of this class
+              instance_exec(**args, &block)
+            end
+          end
+        end
+
+        private
+
+        # Given a method name, or array of method names, this method will yield to the
+        # provided block once for each time a dsl method with one of the provided names
+        # was used within one of the correspondng dsls, on each child_class
+        #
+        # The values of base_class and child_class are set from the yield of the parent
+        # class (ForChildrenOfParser) initializer, the value of dsl_execution is set from
+        # this classes initializer, meaning that the use of this method should look
+        # something like this:
+        #
+        # for_children_of PlatformRecord do |base_class:|
+        #   for_dsl [:number_field, :float_field] do |name:|
+        #     for_method :some_method_name do |method_name:, a_method_argument:|
+        #       ...
+        #     end
+        #   end
+        # end
+        def for_method method_names, &block
+          ForMethodParser.new(@base_class, @child_class, @dsl_execution, method_names, &block)
+        end
+      end
+    end
+  end
+end

data/lib/dsl_compose/parser/for_children_of_parser.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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
+      end
+
+      class NoBlockProvided < StandardError
+      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
+      # that the child also uses at least one of the DSLs which have been defined on the base_class
+      def initialize base_class, &block
+        # assert the provided class has the DSLCompose::Composer module installed
+        unless base_class.respond_to? :dsls
+          raise ClassDoesNotUseDSLComposeError
+        end
+
+        @base_class = base_class
+
+        # assert that a block was provided
+        unless block
+          raise NoBlockProvided
+        end
+
+        # if any arguments were provided, then assert that they are valid
+        if block.parameters.any?
+          # all parameters must be keyword arguments
+          if block.parameters.filter { |p| p.first != :keyreq }.any?
+            raise AllBlockParametersMustBeKeywordParametersError
+          end
+        end
+
+        # yield the provided block for each child class of the provided base_class
+        # which uses a defined DSL
+        base_class.dsls.executions_by_class.each do |child_class, dsl|
+          args = {}
+          if BlockArguments.accepts_argument?(:child_class, &block)
+            args[:child_class] = child_class
+          end
+          # set the child_class in an instance variable so that method calls to
+          # `for_dsl` from within the block will have access to it
+          @child_class = child_class
+          # yield the block in the context of this class
+          instance_exec(**args, &block)
+        end
+      end
+
+      private
+
+      # Given a dsl name, or array of dsl names, this method will yield to the
+      # provided block once for each time a dsl with one of the provided names
+      # was used on the correspondng child_class
+      #
+      # The value of child_class and base_class are set from the yield of this
+      # classes initializer, meaning that the use of this method should look
+      # something like this:
+      #
+      # for_children_of PlatformRecord do |base_class:|
+      #   for_dsl [:number_field, :float_field] do |name:|
+      #     ...
+      #   end
+      # end
+      def for_dsl dsl_names, &block
+        child_class = @child_class
+
+        unless child_class
+          raise NoChildClassError
+        end
+
+        ForDSLParser.new(@base_class, child_class, dsl_names, &block)
+      end
+    end
+  end
+end

data/lib/dsl_compose/parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DSLCompose
+  # A base class for building parsers which can be used to act upon
+  # our dynamically defined DSLs
+  #
+  # Example syntax...
+  #
+  # for_children_of SomeBaseClass do |child_class:|
+  #   for_dsl [:dsl_name1, :dsl_name2] do |dsl_name:, a_dsl_argument:|
+  #     for_method :some_method_name do |method_name:, a_method_argument:|
+  #       ...
+  #     end
+  #   end
+  # end
+  class Parser
+    class NotInitializable < StandardError
+    end
+
+    # this class is not designed to be initialized, the parser is made up of
+    # singlerton methods and is designed to be executed as soon as it is required
+    # into an application
+    def initialize
+      raise NotInitializable
+    end
+
+    # the first step in defining a parser is to set the base_class, this method
+    # will yield to the provided block for each child class of the provided base_class
+    # provided that the child_class uses at least one of the base_classes defined DSLs
+    def self.for_children_of base_class, rerun = false, &block
+      unless rerun
+        @runs ||= []
+        @runs << {
+          base_class: base_class,
+          block: block
+        }
+      end
+
+      # we parse the provided block in the context of the ForChildrenOfParser class
+      # to help make this code more readable, and to limit polluting the current namespace
+      ForChildrenOfParser.new(base_class, &block)
+    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
+    def self.rerun
+      @runs&.each do |run|
+        base_class = run[:base_class]
+        block = run[:block]
+        for_children_of base_class, true, &block
+      end
+    end
+  end
+end

data/lib/dsl_compose/version.rb

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

data/lib/dsl_compose.rb

@@ -29,6 +29,12 @@ require "dsl_compose/interpreter/execution/arguments"
 require "dsl_compose/interpreter/execution"
 require "dsl_compose/interpreter"
 
+require "dsl_compose/parser/for_children_of_parser/for_dsl_parser/for_method_parser"
+require "dsl_compose/parser/for_children_of_parser/for_dsl_parser"
+require "dsl_compose/parser/for_children_of_parser"
+require "dsl_compose/parser/block_arguments"
+require "dsl_compose/parser"
+
 require "dsl_compose/composer"
 
 require "dsl_compose/dsls"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_compose
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-22 00:00:00.000000000 Z
+date: 2023-07-07 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
@@ -47,6 +47,11 @@ files:
 - lib/dsl_compose/interpreter/execution/arguments.rb
 - lib/dsl_compose/interpreter/execution/method_calls.rb
 - lib/dsl_compose/interpreter/execution/method_calls/method_call.rb
+- lib/dsl_compose/parser.rb
+- lib/dsl_compose/parser/block_arguments.rb
+- lib/dsl_compose/parser/for_children_of_parser.rb
+- lib/dsl_compose/parser/for_children_of_parser/for_dsl_parser.rb
+- lib/dsl_compose/parser/for_children_of_parser/for_dsl_parser/for_method_parser.rb
 - lib/dsl_compose/version.rb
 homepage: 
 licenses: