Change param conversion, permitted & validation to return errors as v…

…alues

lib/tty/option/param_conversion.rb

@@ -21,6 +21,8 @@ def call(param, value)
         else
           Conversions[cast].(value)
         end
+      rescue InvalidConversionArgument => err
+        err
       end
       module_function :call
 

lib/tty/option/param_permitted.rb

@@ -16,9 +16,10 @@ def call(param, value)
         if param.permit.include?(value)
           value
         else
-          raise UnpermittedArgument,
-                format("unpermitted argument %s for %s parameter",
-                       value, param.name.inspect)
+          UnpermittedArgument.new(
+            format("unpermitted argument %s for %s parameter",
+                   value, param.name.inspect)
+          )
         end
       end
       module_function :call

lib/tty/option/param_validation.rb

@@ -13,21 +13,24 @@ module ParamValidation
       def call(param, values)
         return values unless param.validate?
 
-        Array(values).each do |value|
-          result = case param.validate
-                   when Proc
-                     param.validate.(value)
-                   when Regexp
-                     !param.validate.match(value.to_s).nil?
-                   end
+        result = Array(values).reduce([]) do |acc, value|
+          valid = case param.validate
+                  when Proc
+                    param.validate.(value)
+                  when Regexp
+                    !param.validate.match(value.to_s).nil?
+                  end
 
-          result || raise(TTY::Option::InvalidArgument.new(
-            format("value of `%s` fails validation rule for %s parameter",
-                   value, param.name.inspect)
-          ))
+          if valid
+            acc << value
+          else
+            acc << TTY::Option::InvalidArgument.new(
+                     format("value of `%s` fails validation rule for %s parameter",
+                            value, param.name.inspect))
+          end
+          acc
         end
-
-        values
+        result.size <= 1 ? result.first : result
       end
       module_function :call
 

lib/tty/option/pipeline.rb

@@ -22,7 +22,12 @@ def initialize(param, value)
       end
 
       def next(callable)
-        self.class.new(@param, callable[@param, @value])
+        result = callable[@param, @value]
+        error = Array(result).find { |res| res.is_a?(Error) }
+        if error
+          raise error
+        end
+        self.class.new(@param, result)
       end
 
       def value

spec/unit/param_conversion_spec.rb

@@ -10,10 +10,10 @@
   it "fails to convert parameter value to expected type" do
     param = TTY::Option::Parameter::Argument.create(:foo, convert: :int)
 
-    expect {
-      described_class[param, "bar"]
-    }.to raise_error(TTY::Option::InvalidConversionArgument,
-                    "Invalid value of \"bar\" for :int conversion")
+    error = described_class[param, "bar"]
+
+    expect(error).to be_an_instance_of(TTY::Option::InvalidConversionArgument)
+    expect(error.message).to eq("Invalid value of \"bar\" for :int conversion")
   end
 
   it "converts parameter value to expected type with a block" do

spec/unit/param_permitted_spec.rb

@@ -16,9 +16,8 @@
   it "doesn't permit an option arguemnt" do
     param = TTY::Option::Parameter::Option.create(:foo, permit: %w[a b c])
 
-    expect {
-      described_class[param, "d"]
-    }.to raise_error(TTY::Option::UnpermittedArgument,
-                    "unpermitted argument d for :foo parameter")
+    error = described_class[param, "d"]
+    expect(error).to be_an_instance_of(TTY::Option::UnpermittedArgument)
+    expect(error.message).to eq("unpermitted argument d for :foo parameter")
   end
 end

spec/unit/param_validation_spec.rb

@@ -22,9 +22,19 @@
   it "fails to accept an option parameter as valid" do
     param = TTY::Option::Parameter::Option.create(:foo, validate: /\d+/)
 
-    expect {
-      described_class[param, "bar"]
-    }.to raise_error(TTY::Option::InvalidArgument,
-                    "value of `bar` fails validation rule for :foo parameter")
+    error = described_class[param, "bar"]
+
+    expect(error).to be_an_instance_of(TTY::Option::InvalidArgument)
+    expect(error.message).to eq(
+      "value of `bar` fails validation rule for :foo parameter"
+    )
+  end
+
+  it "accepts a pram and fails another" do
+    param = TTY::Option::Parameter::Option.create(:foo, validate: /\d{2,}/)
+    error = TTY::Option::InvalidArgument.new(
+              "value of `4` fails validation rule for :foo parameter")
+
+    expect(described_class[param, %w[12 13 4]]).to eq(["12", "13", error])
   end
 end