toys-core 0.14.7 → 0.15.0

data/lib/toys/dsl/flag.rb

@@ -120,7 +120,14 @@ module Toys
       # should be set. You may pass the handler as a Proc (or an object
       # responding to the `call` method) or you may pass a block.
       #
-      # @param handler [Proc]
+      # You can also pass one of the special values `:set` or `:push` as the
+      # handler. The `:set` handler replaces the previous value (equivalent to
+      # `-> (val, _prev) { val }`.) The `:push` handler expects the previous
+      # value to be an array and pushes the given value onto it; it should be
+      # combined with setting the default value to `[]` and is intended for
+      # "multi-valued" flags.
+      #
+      # @param handler [Proc,:set,:push]
       # @param block [Proc]
       # @return [self]
       #
@@ -268,13 +275,36 @@ module Toys
         self
       end
 
+      ##
+      # Specify whether to add a method for this flag.
+      #
+      # Recognized values are true to force creation of a method, false to
+      # disable method creation, and nil for the default behavior. The default
+      # checks the name and adds a method if the name is a symbol representing
+      # a legal method name that starts with a letter and does not override any
+      # public method in the Ruby Object class or collide with any method
+      # directly defined in the tool class.
+      #
+      # @param value [true,false,nil]
+      #
+      def add_method(value)
+        @add_method =
+          if value.nil?
+            nil
+          elsif value
+            true
+          else
+            false
+          end
+      end
+
       ##
       # Called only from DSL::Tool
       #
       # @private
       #
       def initialize(flags, acceptor, default, handler, flag_completion, value_completion,
-                     report_collisions, group, desc, long_desc, display_name)
+                     report_collisions, group, desc, long_desc, display_name, method_flag)
         @flags = flags
         @default = default
         @handler = handler
@@ -286,6 +316,7 @@ module Toys
         accept(acceptor)
         complete_flags(flag_completion, **{})
         complete_values(value_completion, **{})
+        add_method(method_flag)
       end
 
       ##
@@ -298,6 +329,13 @@ module Toys
                       report_collisions: @report_collisions, group: @group,
                       desc: @desc, long_desc: @long_desc, display_name: @display_name)
       end
+
+      ##
+      # @private
+      #
+      def _get_add_method
+        @add_method
+      end
     end
   end
 end

data/lib/toys/dsl/flag_group.rb

@@ -181,19 +181,29 @@ module Toys
       #     arguments.) Defaults to the empty array.
       # @param display_name [String] A display name for this flag, used in help
       #     text and error messages.
+      # @param add_method [true,false,nil] Whether to add a method for this
+      #     flag. If omitted or set to nil, uses the default behavior, which
+      #     adds the method if the key is a symbol representing a legal method
+      #     name that starts with a letter and does not override any public
+      #     method in the Ruby Object class or collide with any method directly
+      #     defined in the tool class.
       # @param block [Proc] Configures the flag. See {Toys::DSL::Flag} for the
       #     directives that can be called in this block.
       # @return [self]
       #
       def flag(key, *flags,
-               accept: nil, default: nil, handler: nil, complete_flags: nil, complete_values: nil,
-               report_collisions: true, desc: nil, long_desc: nil, display_name: nil,
+               accept: nil, default: nil, handler: nil,
+               complete_flags: nil, complete_values: nil,
+               report_collisions: true, desc: nil, long_desc: nil,
+               display_name: nil, add_method: nil,
                &block)
-        flag_dsl = DSL::Flag.new(flags, accept, default, handler, complete_flags, complete_values,
-                                 report_collisions, @flag_group, desc, long_desc, display_name)
+        flag_dsl = DSL::Flag.new(flags, accept, default, handler,
+                                 complete_flags, complete_values,
+                                 report_collisions, @flag_group, desc, long_desc,
+                                 display_name, add_method)
         flag_dsl.instance_exec(flag_dsl, &block) if block
         flag_dsl._add_to(@tool, key)
-        DSL::Internal.maybe_add_getter(@tool_dsl, key)
+        DSL::Internal.maybe_add_getter(@tool_dsl, key, flag_dsl._get_add_method)
         self
       end
 

data/lib/toys/dsl/internal.rb

@@ -8,6 +8,14 @@ module Toys
     # @private
     #
     module Internal
+      ##
+      # @private A list of method names to avoid using as getters
+      #
+      AVOID_GETTERS = (::Object.instance_methods + [:run, :initialize])
+                      .find_all { |name| /^[a-z]\w*$/.match?(name) }
+                      .map { |name| [name, true] }.to_h
+                      .freeze
+
       class << self
         ##
         # Called by the Loader and InputFile to prepare a tool class for running
@@ -91,14 +99,21 @@ module Toys
         #
         # @private
         #
-        def maybe_add_getter(tool_class, key)
-          if key.is_a?(::Symbol) && key.to_s =~ /^[_a-zA-Z]\w*[!?]?$/ && key != :run
-            unless tool_class.public_method_defined?(key)
-              tool_class.class_eval do
-                define_method(key) do
-                  self[key]
-                end
-              end
+        def maybe_add_getter(tool_class, key, force)
+          return unless key.is_a?(::Symbol)
+          case force
+          when false
+            return
+          when true
+            return unless /^[_a-zA-Z]\w*[!?]?$/.match(key.to_s)
+          when nil
+            return if !/^[a-zA-Z]\w*[!?]?$/.match?(key.to_s) ||
+                      AVOID_GETTERS.key?(key) ||
+                      Compat.method_defined_without_ancestors?(tool_class, key)
+          end
+          tool_class.class_eval do
+            define_method(key) do
+              self[key]
             end
           end
         end

data/lib/toys/dsl/positional_arg.rb

@@ -141,18 +141,42 @@ module Toys
         self
       end
 
+      ##
+      # Specify whether to add a method for this argument.
+      #
+      # Recognized values are true to force creation of a method, false to
+      # disable method creation, and nil for the default behavior. The default
+      # checks the name and adds a method if the name is a symbol representing
+      # a legal method name that starts with a letter and does not override any
+      # public method in the Ruby Object class or collide with any method
+      # directly defined in the tool class.
+      #
+      # @param value [true,false,nil]
+      #
+      def add_method(value)
+        @add_method =
+          if value.nil?
+            nil
+          elsif value
+            true
+          else
+            false
+          end
+      end
+
       ##
       # Called only from DSL::Tool
       #
       # @private
       #
-      def initialize(acceptor, default, completion, display_name, desc, long_desc)
+      def initialize(acceptor, default, completion, display_name, desc, long_desc, method_flag)
         @default = default
         @display_name = display_name
         @desc = desc
         @long_desc = long_desc || []
         accept(acceptor, **{})
         complete(completion, **{})
+        add_method(method_flag)
       end
 
       ##
@@ -181,6 +205,13 @@ module Toys
                                 accept: @acceptor, default: @default, complete: @completion,
                                 display_name: @display_name, desc: @desc, long_desc: @long_desc)
       end
+
+      ##
+      # @private
+      #
+      def _get_add_method
+        @add_method
+      end
     end
   end
 end