dsl_compose 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cb2c822a8b9538706989731334fe26334b83e65a59d2e9ecb124f90683273ed
-  data.tar.gz: e82f983c0bb311bf57458546e8539842f6ba722252f64d200b39467b0045994d
+  metadata.gz: c1a173b5c152d3e0e4ac3867b9f55989593a82f724ad27c26aa0445500c81295
+  data.tar.gz: 391d451dcef58cf46915b0b54249b527097210d916aa041e1d49de4c576845d8
 SHA512:
-  metadata.gz: fe00a6f40481346f1eea34ed6f864dd70661d7bfb70753bd2142d793f3c5bf93f2999521cbcb19ddf3082bf11bac8613f2424fa5f4de2edf3345c13d12984ad6
-  data.tar.gz: ad22470dd58fc30f6c5e2918afd60e3c6e22fea32dbee021fbb93aeabaa21a58de61e78c92d90d1399c9142e8d836375722efe21e5094df7135ba0bfefd12584
+  metadata.gz: 9d049bc5ed8c830468376cefcb198fc2671c7eff26b9a0a3fff33377d0ac2c27c03f2b2c2fa1527ef648a847667d5fe58b814c355f058e5cb3bceb80439e0ac7
+  data.tar.gz: 7af648a16098f0ce9b6a0c20936b0b87195cf0e2c8e7869769b5ff293d059b6ca39a0da30b15fb1605d558faeaf5965e616c3cb253bc34daec6e683879ee4da9

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* adding an executions_by_class method to make processing the configuration more convenient ([#8](https://github.com/craigulliott/dsl_compose/issues/8)) ([313507c](https://github.com/craigulliott/dsl_compose/commit/313507ca572f59c03162a91d58e62500a9464f25))
+* fixing release please job ([#10](https://github.com/craigulliott/dsl_compose/issues/10)) ([880fa5b](https://github.com/craigulliott/dsl_compose/commit/880fa5b2aceed67aa9ff1e7cf53629af23e31b10))
+
 ## [1.2.0](https://github.com/craigulliott/dsl_compose/compare/v1.1.0...v1.2.0) (2023-06-22)
 
 

data/README.md

@@ -13,7 +13,7 @@ Ruby gem to add dynamic DSLs to 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
+* Complete 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 added to classes by including the DSLCompose::Composer module, and then calling the define_dsl singleton method within the class or a child class.
 
 ### Defining your DSL
 
@@ -48,6 +48,18 @@ 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 enter 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
@@ -83,7 +95,7 @@ class Foo
       #
       # 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
+      requires :first_method_argument, :string 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"
@@ -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
+  my_dsl :first_dsl_argument, do
+    my_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/composer.rb

@@ -10,13 +10,13 @@ module DSLCompose
 
     class MethodAlreadyExistsWithThisDSLNameError < StandardError
       def message
-        "The define_dsl singleton method already exists for this class."
+        "The `define_dsl` singleton method already exists for this class."
       end
     end
 
     class GetDSLExecutionResultsMethodAlreadyExistsError < StandardError
       def message
-        "The dsl_interpreter singleton method already exists for this class."
+        "The `dsls` singleton method already exists for this class."
       end
     end
 
@@ -30,11 +30,11 @@ module DSLCompose
       interpreter = DSLCompose::Interpreter.new
 
       # return a specific DSL which is defined for this class
-      if klass.respond_to? :dsl_interpreter
+      if klass.respond_to? :dsls
         raise GetDSLExecutionResultsMethodAlreadyExistsError
       end
 
-      klass.define_singleton_method :dsl_interpreter do
+      klass.define_singleton_method :dsls do
         interpreter
       end
 

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|
@@ -46,5 +51,23 @@ module DSLCompose
       end
       h
     end
+
+    def executions_by_class
+      h = {}
+      executions.each do |execution|
+        h[execution.klass] ||= {}
+        h[execution.klass][execution.dsl.name] ||= []
+        execution_h = {
+          arguments: execution.arguments.to_h,
+          method_calls: {}
+        }
+        execution.method_calls.method_calls.each do |method_call|
+          execution_h[:method_calls][method_call.method_name] ||= []
+          execution_h[:method_calls][method_call.method_name] << method_call.to_h
+        end
+        h[execution.klass][execution.dsl.name] << execution_h
+      end
+      h
+    end
   end
 end

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,36 @@
+# 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, &block
+      # 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
+  end
+end

data/lib/dsl_compose/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DSLCompose
-  VERSION = "1.2.0"
+  VERSION = "1.4.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.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-22 00:00:00.000000000 Z
+date: 2023-06-26 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: