redo the returned object as a Struct with a to_a method.

Author: Guy Boertje

Diff for: lib/logstash/inputs/file.rb

@@ -229,9 +229,9 @@ class << self
 
     def validate_value(value, validator)
       if validator.is_a?(Array) && validator.size == 2 && validator.first.respond_to?(:call)
-        callable, units, val = *validator, value
-        validation_errors = callable.call(value, units){|coerced| val = coerced}
-        return validation_errors.nil? ? [true, val] : [false, validation_errors]
+        callable, units = *validator
+        # returns a ValidatedStruct having a `to_a` method suitable to return to the config mixin caller
+        return callable.call(value, units).to_a
       end
       old_validate_value(value, validator)
     end

Diff for: lib/logstash/inputs/friendly_durations.rb

@@ -8,38 +8,37 @@ module FriendlyDurations
     MEGA = 10**6
     KILO = 10**3
 
-    def self.call(value, unit = "sec")
-      val_string = value.to_s.strip
-      result = coerce_in_seconds(val_string, unit)
-      return result if result.is_a?(String)
-      yield result
-      nil
+    ValidatedStruct = Struct.new(:value, :error_message) do
+      def to_a
+        error_message.nil? ? [true, value] : [false, error_message]
+      end
     end
 
-    private
-
-    def self.coerce_in_seconds(value, unit)
-      matched = NUMBERS_RE.match(value)
+    def self.call(value, unit = "sec")
+      # coerce into seconds
+      val_string = value.to_s.strip
+      matched = NUMBERS_RE.match(val_string)
       if matched.nil?
-        return "Value '#{value}' is not a valid duration string e.g. 200 usec, 250ms, 60 sec, 18h, 21.5d, 1 day, 2w, 6 weeks"
+        failed_message = "Value '#{val_string}' is not a valid duration string e.g. 200 usec, 250ms, 60 sec, 18h, 21.5d, 1 day, 2w, 6 weeks"
+        return ValidatedStruct.new(nil, failed_message)
       end
       multiplier = matched[:units] || unit
       numeric = matched[:number].to_f
       case multiplier
       when "m","min","mins","minute","minutes"
-        numeric * 60
+        ValidatedStruct.new(numeric * 60, nil)
       when "h","hour","hours"
-        numeric * HOURS
+        ValidatedStruct.new(numeric * HOURS, nil)
       when "d","day","days"
-        numeric * DAYS
+        ValidatedStruct.new(numeric * DAYS, nil)
       when "w","week","weeks"
-        numeric * 7 * DAYS
+        ValidatedStruct.new(numeric * 7 * DAYS, nil)
       when "ms","msec","msecs"
-        numeric / KILO
+        ValidatedStruct.new(numeric / KILO, nil)
       when "us","usec","usecs"
-        numeric / MEGA
+        ValidatedStruct.new(numeric / MEGA, nil)
       else
-        numeric
+        ValidatedStruct.new(numeric, nil)
       end
     end
   end

Diff for: spec/inputs/friendly_durations_spec.rb

@@ -7,22 +7,23 @@
   context "unacceptable strings" do
     it "gives an error message for 'foobar'" do
       result = LogStash::Inputs::FriendlyDurations.call("foobar","sec")
-      expect(result).to start_with("Value 'foobar' is not a valid duration string e.g. 200 usec")
+      expect(result.error_message).to start_with("Value 'foobar' is not a valid duration string e.g. 200 usec")
     end
     it "gives an error message for '5 5 days'" do
       result = LogStash::Inputs::FriendlyDurations.call("5 5 days","sec")
-      expect(result).to start_with("Value '5 5 days' is not a valid duration string e.g. 200 usec")
+      expect(result.error_message).to start_with("Value '5 5 days' is not a valid duration string e.g. 200 usec")
     end
   end
 
   context "when a unit is not specified, a unit override will affect the result" do
-    it "coerces 14 to 1209600.0 as days with a block callback" do
-      result = LogStash::Inputs::FriendlyDurations.call(14,"d"){|value| expect(value).to eq(1209600.0)}
-      expect(result).to eq(nil)
+    it "coerces 14 to 1209600.0s as days" do
+      result = LogStash::Inputs::FriendlyDurations.call(14,"d")
+      expect(result.error_message).to eq(nil)
+      expect(result.value).to eq(1209600.0)
     end
-    it "coerces '30' to 1800 as minutes with a block callback" do
-      result = LogStash::Inputs::FriendlyDurations.call("30","minutes"){|value| expect(value).to eq(1800.0)}
-      expect(result).to eq(nil)
+    it "coerces '30' to 1800.0s as minutes" do
+      result = LogStash::Inputs::FriendlyDurations.call("30","minutes")
+      expect(result.to_a).to eq([true, 1800.0])
     end
   end
 
@@ -61,9 +62,9 @@
       ["2 weeks",      1209600.0],
       ["1.5 weeks",     907200.0],
     ].each do |input, coerced|
-      it "coerces #{input.inspect.rjust(16)} to #{coerced.inspect} with a block callback" do
-        result = LogStash::Inputs::FriendlyDurations.call(input,"sec"){|value| expect(value).to eq(coerced)}
-        expect(result).to eq(nil)
+      it "coerces #{input.inspect.rjust(16)} to #{coerced.inspect}" do
+        result = LogStash::Inputs::FriendlyDurations.call(input,"sec")
+        expect(result.to_a).to eq([true, coerced])
       end
     end
   end