dsl_compose 2.12.0 → 2.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31077b216dc51cdf2addc2bb7d094ca58d7cb90ed7ff82897712c3a46b709e10
-  data.tar.gz: 51d663846f488abdd48a57eaf643e8d89bc9cd5db5d8ca4d4914c610debd2ca9
+  metadata.gz: 117789e8395652f4823ad048b258d2a683b65328d5817788b9d3d3d7bc377c8b
+  data.tar.gz: d4ad4b7a66de0cfd143006e4c9984bef0ce1c29e6e18b86a0621810cb2d11edb
 SHA512:
-  metadata.gz: fc5cbde44a97a3fb2920c7e9b4bfb669ba535168e09edb68c1597ad80a2bc41aaa61aaa52c7aea233ce740f8304f6a65691d0a92072fc40ebdabb5277f6617f2
-  data.tar.gz: 9f26a35cf368934b91967768870f1c863615746d12790a1334659ee852faab53b6dabc9182a13fe74d525dbefb2f8194a8ff83454ede48d935e9651058036af3
+  metadata.gz: dbcf361a908dcd619664f12e50299f80092d5e2f4e8efb4f53320b2d13c3ca30ef334e429fe1a977fb899c0878f2dd26a30d9b067b74da22198eb2372984d2ad
+  data.tar.gz: 9e932a4d10693634bc25532d9d625ad1939f58c975bf90a0f4a0f1714586bdce5dc1650cf48cbfaa0655c56fbaa341fd27731953e4e3fe74fbefd63619fac6ad

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.13.1](https://github.com/craigulliott/dsl_compose/compare/v2.13.0...v2.13.1) (2023-09-05)
+
+
+### Bug Fixes
+
+* fixed a nil value in error message caused by overwriting method argument ([dd7848b](https://github.com/craigulliott/dsl_compose/commit/dd7848b3861bff6176c8326f6784fb29f1ba2fdd))
+
+## [2.13.0](https://github.com/craigulliott/dsl_compose/compare/v2.12.0...v2.13.0) (2023-09-04)
+
+
+### Features
+
+* optionally mark required arguments as keyword arguments ([9a1c901](https://github.com/craigulliott/dsl_compose/commit/9a1c90169fb36c550b0577034823579062120647))
+
 ## [2.12.0](https://github.com/craigulliott/dsl_compose/compare/v2.11.0...v2.12.0) (2023-09-02)
 
 

data/README.md

@@ -114,6 +114,16 @@ class Foo
         validate_greater_than 0
       end
 
+      # Required arguments for both DSLs and DSL methods are assumed to be standard ruby
+      # arguments by default, but can be declared as keyword arguments by passing `kwarg: true`.
+      # This is useful because sometimes keyword arguments can make your DSL more readable. This
+      # option does not exist for optional arguments, because optional arguments are always kwargs.
+      requires :required_keyword_argument, :symbol, kwarg: true 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
+
       # All optional and required arguments can optionally accept an array of values. When using
       # your final DSL, a single item can be provided but will automatically be converted to an
       # array of items. All items in the array must be of the expected type.

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

@@ -13,6 +13,9 @@ module DSLCompose
         class InvalidTypeError < StandardError
         end
 
+        class ImpossibleKwargError < StandardError
+        end
+
         class InvalidNameError < StandardError
         end
 
@@ -42,6 +45,10 @@ module DSLCompose
         attr_reader :type
         # if required, then this Argument must be provided when calling its associated DSLMethod.
         attr_reader :required
+        # If true, then this argument must be provided as a keyword argument, this is only appropriate for
+        # required arguments, as optional arguments are always passed as keywork arguments.
+        # arguments.
+        attr_reader :kwarg
         # If true, then this argument accepts an array of values. It will also accept a single value,
         # but that single value will be automatically converted to an array
         attr_reader :array
@@ -71,9 +78,10 @@ module DSLCompose
         # `name` must be a symbol.
         # `required` is a boolean which determines if this Attribute must be provided when
         # calling its associated DSLMethod.
+        # `kwarg` is a boolean which determines if a required Attribute must be provided as a keyword argument.
         # `type` can be either :integer, :boolean, :float, :string or :symbol
         # `block` contains the instructions to further configure this Attribute
-        def initialize name, required, type, array: false, &block
+        def initialize name, required, kwarg, type, array: false, &block
           if name.is_a? Symbol
 
             if RESERVED_ARGUMENT_NAMES.include? name
@@ -93,6 +101,12 @@ module DSLCompose
 
           @required = required ? true : false
 
+          if @required == false && kwarg == true
+            raise ImpossibleKwargError, "Optional arguments must always be provided as keyword arguments. The argument `#{name}` can not be both required: false and kwarg: true."
+          end
+
+          @kwarg = kwarg ? true : false
+
           @array = array ? true : false
 
           # If a block was provided, then we evaluate it using a seperate

data/lib/dsl_compose/dsl/arguments.rb

@@ -85,8 +85,9 @@ module DSLCompose
       #
       # Argument `name` must be unique within the DSLMethod.
       # `required` must be a boolean, and determines if this argument will be required
+      # `kwarg` is a boolean which determines if a required Attribute must be provided as a keyword argument.
       # or optional on the method which is exposed in our DSL.
-      def add_argument name, required, type, array: false, &block
+      def add_argument name, required, kwarg, type, array: false, &block
         if @arguments.key? name
           raise ArgumentAlreadyExistsError, "An argument with the name `#{name}` already exists for this DSL method"
         end
@@ -96,7 +97,7 @@ module DSLCompose
           raise ArgumentOrderingError, "Required arguments can not be added after optional ones"
         end
 
-        @arguments[name] = Argument.new(name, required, type, array: array, &block)
+        @arguments[name] = Argument.new(name, required, kwarg, type, array: array, &block)
       end
     end
   end

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

@@ -39,17 +39,19 @@ module DSLCompose
         # `block` contains the argument definition and will be evaluated seperately
         # by the Argument::Interpreter
         def optional name, type, array: false, &block
-          @dsl_method.arguments.add_argument name, false, type, array: array, &block
+          @dsl_method.arguments.add_argument name, false, false, type, array: array, &block
         end
 
         # adds a new required argument to the DSLMethod
         #
         # name must be a symbol
+        # `kwarg` is a boolean which determines if a required Attribute must be provided as a keyword argument.
+        # `array` is a boolean which determines if this argument will accept an array of the given type or a single item
         # `type` can be either :integer, :boolean, :float, :string or :symbol
         # `block` contains the argument definition and will be evaluated seperately
         # by the Argument::Interpreter
-        def requires name, type, array: false, &block
-          @dsl_method.arguments.add_argument name, true, type, array: array, &block
+        def requires name, type, kwarg: false, array: false, &block
+          @dsl_method.arguments.add_argument name, true, kwarg, type, array: array, &block
         end
 
         # executes the shared configuration block with the given name within the

data/lib/dsl_compose/dsl/interpreter.rb

@@ -66,17 +66,19 @@ module DSLCompose
       # `block` contains the argument definition and will be evaluated seperately
       # by the Argument::Interpreter
       def optional name, type, array: false, &block
-        @dsl.arguments.add_argument name, false, type, array: array, &block
+        @dsl.arguments.add_argument name, false, false, type, array: array, &block
       end
 
       # adds a new required argument to the DSLMethod
       #
       # name must be a symbol
+      # `kwarg` is a boolean which determines if a required Attribute must be provided as a keyword argument.
+      # `array` is a boolean which determines if this argument will accept an array of the given type or a single item
       # `type` can be either :integer, :boolean, :float, :string, :symbol, :class or :object
       # `block` contains the argument definition and will be evaluated seperately
       # by the Argument::Interpreter
-      def requires name, type, array: false, &block
-        @dsl.arguments.add_argument name, true, type, array: array, &block
+      def requires name, type, kwarg: false, array: false, &block
+        @dsl.arguments.add_argument name, true, kwarg, type, array: array, &block
       end
 
       # executes the shared configuration block with the given name within the

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

@@ -25,18 +25,38 @@ module DSLCompose
           @arguments = {}
 
           required_argument_count = arguments.required_arguments.count
+          required_non_kwarg_argument_count = arguments.required_arguments.count { |a| !a.kwarg }
           has_optional_arguments = arguments.optional_arguments.any?
 
-          # the first N args, where N = required_argument_count, are the
+          # the first N args, where N = required_non_kwarg_argument_count, are the
           # provided required arguments
-          required_args = args.slice(0, required_argument_count)
-          # the optional arg which comes next is the hash which represents
-          # all the optional arguments
-          optional_arg = args[required_argument_count]
+          required_args = args.slice(0, required_non_kwarg_argument_count)
+
+          # the final argument is the object which contains all the keyword args (these keyword
+          # args could be optional or required)
+          all_kwargs = args[required_non_kwarg_argument_count]
+
+          # process all the required arguments which are kwargs
+          required_kwargs = arguments.required_arguments.filter { |a| a.kwarg }
+          required_kwargs.each do |required_kwarg|
+            if all_kwargs.key? required_kwarg.name
+              # add the keyword argument to the required args
+              required_args << all_kwargs[required_kwarg.name]
+              # delete the required kwarg from the kwargs hash, so that we are
+              # left with only the optional args
+              all_kwargs.delete required_kwarg.name
+            else
+              raise MissingRequiredArgumentsError, "The required kwarg `#{required_kwarg.name}` was not provided"
+            end
+          end
+
+          # at this point, all_kwargs should be a hash which only represents
+          # the optional arguments
+          optional_arg = all_kwargs
 
           # assert that a value is provided for every required argument
           unless required_argument_count == required_args.count
-            raise MissingRequiredArgumentsError, "This requires #{required_argument_count} arguments, but only #{required_args.count} were provided"
+            raise MissingRequiredArgumentsError, "This requires #{required_non_kwarg_argument_count} arguments, but only #{required_args.count} were provided"
           end
 
           # assert that too many arguments have not been provided
@@ -61,7 +81,7 @@ module DSLCompose
           end
 
           # asset that, if provided, then the optional argument (always the last one) is a Hash
-          if has_optional_arguments && optional_arg.nil? === false
+          if has_optional_arguments && !optional_arg.nil?
             unless optional_arg.is_a? Hash
               raise OptionalArgumentsShouldBeHashError, "If provided, then the optional arguments must be last, and be represented as a Hash"
             end
@@ -165,13 +185,13 @@ module DSLCompose
             # to the corresponding class, logic which doesn't happen here in case the class doesnt
             # exist yet)
             required_arg_value = if required_argument.type == :class
-              if args[i].is_a?(Array)
-                args[i].map { |v| ClassCoerce.new v }
+              if required_args[i].is_a?(Array)
+                required_args[i].map { |v| ClassCoerce.new v }
               else
-                ClassCoerce.new args[i]
+                ClassCoerce.new required_args[i]
               end
             else
-              args[i]
+              required_args[i]
             end
 
             if required_arg_value.is_a?(Array) && !required_argument.array

data/lib/dsl_compose/reader.rb

@@ -24,24 +24,25 @@ module DSLCompose
       # Move up through this classes ancestors until we find the class which defined
       # the DSL with the provided name. When we reach the top of the ancestor chain we
       # exit the loop.
-      while klass
+      k = klass
+      while k
         # if we find a DSL with this name, then store a reference to the DSL and the
         # ancestor class where it was defined
-        if DSLs.class_dsl_exists?(klass, dsl_name)
-          @dsl = DSLs.class_dsl(klass, dsl_name)
-          @dsl_defining_class = klass
+        if DSLs.class_dsl_exists?(k, dsl_name)
+          @dsl = DSLs.class_dsl(k, dsl_name)
+          @dsl_defining_class = k
           # stop once we find the DSL
           break
         end
 
         # the DSL was not found here, so traverse up the provided classes hierachy
         # and keep looking for where this DSL was initially defined
-        klass = klass.superclass
+        k = k.superclass
       end
 
       # if no DSL was found, then raise an error
       if @dsl.nil? && @dsl_defining_class.nil?
-        raise DSLNotFound, "No DSL named `#{dsl_name}` was found for class `#{klass}`"
+        raise DSLNotFound, "No DSL named `#{dsl_name}` was found for class `#{@klass}`"
       end
     end
 

data/lib/dsl_compose/version.rb

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

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

@@ -9,6 +9,7 @@ module DSLCompose
         attr_reader name: Symbol
         attr_reader type: argument_type
         attr_reader required: bool
+        attr_reader kwarg: bool
         attr_reader array: bool
         attr_reader description: String
 
@@ -27,7 +28,7 @@ module DSLCompose
         attr_reader length_validation: LengthValidation
         attr_reader is_a_validation: IsAValidation
 
-        def initialize: (Symbol name, bool required, argument_type `type`, ?array: bool) -> void
+        def initialize: (Symbol name, bool required, bool kwarg, argument_type `type`, ?array: bool) -> void
         def set_description: (String description) -> void
         def has_description?: () -> bool
         def required?: -> bool

data/sig/dsl_compose/dsl/arguments.rbs

@@ -12,7 +12,7 @@ module DSLCompose
       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
+      def add_argument: (Symbol name, bool required, bool kwarg, argument_type `type`, ?array: bool) -> Argument
 
       class ArgumentDoesNotExistError < StandardError
         end

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

@@ -11,7 +11,7 @@ module DSLCompose
         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
+        def requires: (Symbol name, argument_type `type`, ?kwarg: bool, ?array: bool) -> void
       end
     end
   end

data/sig/dsl_compose/dsl/interpreter.rbs

@@ -14,7 +14,7 @@ module DSLCompose
       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
+      def requires: (Symbol name, argument_type `type`, ?kwarg: bool, ?array: bool) -> void
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsl_compose
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.1
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: class_spec_helper