Fix issue with blank strings and type extensions (luckyframework#381)

* Fix issue with blank strings and type extensions

Closes luckyframework#377

* Missed a spec to match all of the others

* removing commented code

* Adding this Nil now allows specs to compile and pass

* removed duplicate method

Co-authored-by: Jeremy Woertink <jeremywoertink@gmail.com>

spec/type_extensions/array_spec.cr

@@ -2,32 +2,32 @@ require "../spec_helper"
 
 describe "Array" do
   it "parses Array(Bool) from Array(String)" do
-    result = Bool::Lucky.parse(["true"])
-    result.value.should eq([true])
+    result = Bool::Lucky.parse!(["true"])
+    result.should eq([true])
   end
 
   it "parses Array(String)" do
-    result = String::Lucky.parse(["test"])
-    result.value.should eq(["test"])
+    result = String::Lucky.parse!(["test"])
+    result.should eq(["test"])
   end
 
   it "parses Array(Int32) from Array(String)" do
-    result = Int32::Lucky.parse(["10"])
-    result.value.should eq([10])
+    result = Int32::Lucky.parse!(["10"])
+    result.should eq([10])
   end
 
   it "parses Array(Int16) from Array(String)" do
-    result = Int16::Lucky.parse(["1"])
-    result.value.should eq([1_i16])
+    result = Int16::Lucky.parse!(["1"])
+    result.should eq([1_i16])
   end
 
   it "parses Array(Int64) from Array(String)" do
-    result = Int64::Lucky.parse(["1000"])
-    result.value.should eq([1000_i64])
+    result = Int64::Lucky.parse!(["1000"])
+    result.should eq([1000_i64])
   end
 
   it "parses Array(Float64) from Array(String)" do
-    result = Float64::Lucky.parse(["3.1415"])
-    result.value.should eq([3.1415])
+    result = Float64::Lucky.parse!(["3.1415"])
+    result.should eq([3.1415])
   end
 end

spec/type_extensions/bool_spec.cr

@@ -6,4 +6,21 @@ describe Bool do
       true.blank?.should be_false
     end
   end
+
+  describe "parsing" do
+    it "parses empty string as nil" do
+      parse("").should be_a(Avram::Type::SuccessfulCast(Nil))
+    end
+
+    it "parses strings" do
+      parse("true").value.should eq(true)
+      parse("1").value.should eq(true)
+      parse("false").value.should eq(false)
+      parse("0").value.should eq(false)
+    end
+  end
+end
+
+private def parse(value)
+  Bool::Lucky.parse(value)
 end

spec/type_extensions/enum_spec.cr

@@ -3,14 +3,22 @@ require "../spec_helper"
 include LazyLoadHelpers
 
 describe "Enum" do
-  it "check enum" do
+  it "parses String enum" do
+    Issue::Status::Lucky.parse("1").value.should eq(Issue::Status.new(Issue::AvramStatus::Closed))
+  end
+
+  it "parses empty String enum" do
+    Issue::Status::Lucky.parse("").should be_a(Avram::Type::SuccessfulCast(Nil))
+  end
+
+  it "checks enum" do
     issue = IssueBox.create
 
     issue.status.enum.should eq(Issue::AvramStatus::Opened)
     issue.role.enum.should eq(Issue::AvramRole::Issue)
   end
 
-  it "update enum" do
+  it "updates enum" do
     issue = IssueBox.create
 
     updated_issue = Issue::SaveOperation.update!(issue, status: Issue::Status.new(:closed))
@@ -19,7 +27,7 @@ describe "Enum" do
     updated_issue.role.enum.should eq(Issue::AvramRole::Issue)
   end
 
-  it "access enum methods" do
+  it "accesses enum methods" do
     issue = IssueBox.create
 
     issue.status.opened?.should eq(true)

spec/type_extensions/int_spec.cr

@@ -0,0 +1,67 @@
+require "../spec_helper"
+
+describe "Int16" do
+  it "parses Int16 from String" do
+    result = Int16::Lucky.parse("10")
+    result.value.should eq(10_i16)
+  end
+
+  it "parses Int16 from Int32" do
+    result = Int16::Lucky.parse(400)
+    result.value.should eq(400_i16)
+  end
+
+  it "returns FailedCast when overflow from Int16 to Int32/64" do
+    result = Int16::Lucky.parse(1234556)
+    result.value.should eq(nil)
+    result.should be_a(Avram::Type::FailedCast)
+  end
+
+  it "returns nil if String is blank" do
+    result = Int16::Lucky.parse("")
+    result.value.should be_nil
+    result.should be_a(Avram::Type::SuccessfulCast(Nil))
+  end
+end
+
+describe "Int32" do
+  it "parses Int32 from String" do
+    result = Int32::Lucky.parse("10")
+    result.value.should eq(10)
+  end
+
+  it "parses Int32 from Int64" do
+    result = Int32::Lucky.parse(400_i64)
+    result.value.should eq(400)
+  end
+
+  it "returns FailedCast when overflow from Int64 to Int32" do
+    result = Int32::Lucky.parse(2147483648)
+    result.value.should eq(nil)
+    result.should be_a(Avram::Type::FailedCast)
+  end
+
+  it "returns nil if String is blank" do
+    result = Int32::Lucky.parse("")
+    result.value.should be_nil
+    result.should be_a(Avram::Type::SuccessfulCast(Nil))
+  end
+end
+
+describe "Int64" do
+  it "parses Int64 from String" do
+    result = Int64::Lucky.parse("10")
+    result.value.should eq(10_i64)
+  end
+
+  it "parses Int64 from Int32" do
+    result = Int64::Lucky.parse(400)
+    result.value.should eq(400_i64)
+  end
+
+  it "returns nil if String is blank" do
+    result = Int64::Lucky.parse("")
+    result.value.should be_nil
+    result.should be_a(Avram::Type::SuccessfulCast(Nil))
+  end
+end

spec/type_extensions/time_spec.cr

@@ -2,6 +2,12 @@ require "../spec_helper"
 
 describe "Time column type" do
   describe ".parse" do
+    it "returns nil if parsing an empty String" do
+      result = Time::Lucky.parse("")
+
+      result.should be_a(Avram::Type::SuccessfulCast(Nil))
+    end
+
     it "casts various formats successfully" do
       time = Time.local
       times = {

spec/type_extensions/uuid_spec.cr

@@ -2,6 +2,10 @@ require "../spec_helper"
 
 describe "UUID column type" do
   describe ".parse" do
+    it "returns successful cast if string is nil" do
+      UUID::Lucky.parse("").should be_a(Avram::Type::SuccessfulCast(Nil))
+    end
+
     it "casts a UUID successfully" do
       uuid = UUID.new("a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11")
       UUID::Lucky.parse(uuid).value.should eq uuid

src/avram/charms/bool_extensions.cr

@@ -8,6 +8,8 @@ struct Bool
     include Avram::Type
 
     def parse(value : String)
+      return parse(nil) if value.blank?
+
       if %w(true 1).includes? value
         SuccessfulCast(Bool).new true
       elsif %w(false 0).includes? value

src/avram/charms/enum_extensions.cr

@@ -8,6 +8,7 @@ macro avram_enum(enum_name, &block)
       Lucky
     end
 
+    def_equals @enum
     getter :enum
 
     # You may need to prefix with {{ @type }}
@@ -41,6 +42,7 @@ macro avram_enum(enum_name, &block)
       end
 
       def parse(value : String)
+        return parse(nil) if value.blank?
         SuccessfulCast({{ enum_name }}).new({{ enum_name }}.new(value.to_i))
       end
 

src/avram/charms/int16_extensions.cr

@@ -20,6 +20,7 @@ struct Int16
     end
 
     def parse(value : String)
+      return parse(nil) if value.blank?
       SuccessfulCast(Int16).new value.to_i16
     rescue ArgumentError
       FailedCast.new

src/avram/charms/int32_extensions.cr

@@ -12,6 +12,7 @@ struct Int32
     end
 
     def parse(value : String)
+      return parse(nil) if value.blank?
       SuccessfulCast(Int32).new value.to_i
     rescue ArgumentError
       FailedCast.new

src/avram/charms/int64_extensions.cr

@@ -20,6 +20,7 @@ struct Int64
     end
 
     def parse(value : String)
+      return parse(nil) if value.blank?
       SuccessfulCast(Int64).new value.to_i64
     rescue ArgumentError
       FailedCast.new

src/avram/charms/time_extensions.cr

@@ -22,7 +22,9 @@ struct Time
       value
     end
 
-    def parse(value : String) : SuccessfulCast(Time) | FailedCast
+    def parse(value : String) : SuccessfulCast(Time) | SuccessfulCast(Nil) | FailedCast
+      return parse(nil) if value.blank?
+
       # Prefer user defined string formats
       try_parsing_with_string_formats(value) ||
         # Then try default formats

src/avram/charms/uuid_extensions.cr

@@ -16,6 +16,7 @@ struct UUID
     end
 
     def parse(value : String)
+      return parse(nil) if value.blank?
       SuccessfulCast(UUID).new(UUID.new(value))
     rescue
       FailedCast.new

src/avram/type.cr

@@ -14,13 +14,18 @@ module Avram::Type
   def parse(values : Array(String))
     casts = values.map { |value| parse(value) }
     if casts.all?(&.is_a?(SuccessfulCast))
-      values = casts.map { |c| c.as(SuccessfulCast).value }
-      parse(values)
+      casts.map(&.as(SuccessfulCast))
     else
       FailedCast.new
     end
   end
 
+  def parse!(values : Array(T)) forall T
+    values.map do |v|
+      parse!(v)
+    end
+  end
+
   def parse!(value)
     parse(value).as(SuccessfulCast).value
   end

src/avram/where.cr

@@ -38,7 +38,7 @@ module Avram::Where
   end
 
   abstract class ValueHoldingSqlClause < SqlClause
-    getter value : String | Array(String) | Array(Int32)
+    getter value : String | Array(String) | Array(Int32) | Nil
 
     def initialize(@column, @value)
     end