Add Enum.parse(Bytes) and Enum.parse?(Bytes)

spec/std/enum_spec.cr

@@ -307,7 +307,7 @@ describe Enum do
     SpecEnum::Two.hash.should_not eq(SpecEnum::Three.hash)
   end
 
-  it ".parse" do
+  it ".parse(String)" do
     SpecEnum.parse("Two").should eq(SpecEnum::Two)
     SpecEnum2.parse("FortyTwo").should eq(SpecEnum2::FortyTwo)
     SpecEnum2.parse("forty_two").should eq(SpecEnum2::FortyTwo)
@@ -336,10 +336,43 @@ describe Enum do
     SpecEnumWithCaseSensitiveMembers.parse("Foo").should eq SpecEnumWithCaseSensitiveMembers::FOO
   end
 
+  it ".parse(Bytes)" do
+    SpecEnum.parse("Two".to_slice).should eq(SpecEnum::Two)
+    SpecEnum2.parse("FortyTwo".to_slice).should eq(SpecEnum2::FortyTwo)
+    SpecEnum2.parse("forty_two".to_slice).should eq(SpecEnum2::FortyTwo)
+    expect_raises(ArgumentError, "Unknown enum SpecEnum value: #{"Four".to_slice}") { SpecEnum.parse("Four".to_slice) }
+
+    SpecEnum.parse("TWO".to_slice).should eq(SpecEnum::Two)
+    SpecEnum.parse("TwO".to_slice).should eq(SpecEnum::Two)
+    SpecEnum2.parse("FORTY_TWO".to_slice).should eq(SpecEnum2::FortyTwo)
+    SpecEnum2.parse("FORTY___TWO".to_slice).should eq(SpecEnum2::FortyTwo)
+    SpecEnum2.parse("FORTY___TWO_".to_slice).should eq(SpecEnum2::FortyTwo)
+
+    SpecEnum2.parse("FORTY_FOUR".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+    SpecEnum2.parse("forty_four".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+    SpecEnum2.parse("FORTY-FOUR".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+    SpecEnum2.parse("forty-four".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+    SpecEnum2.parse("FortyFour".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+    SpecEnum2.parse("FORTYFOUR".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+    SpecEnum2.parse("fortyfour".to_slice).should eq(SpecEnum2::FORTY_FOUR)
+
+    PrivateEnum.parse("FOO".to_slice).should eq(PrivateEnum::FOO)
+    PrivateEnum.parse("BAR".to_slice).should eq(PrivateEnum::BAR)
+    PrivateEnum.parse("QUX".to_slice).should eq(PrivateEnum::QUX)
+
+    SpecEnumWithCaseSensitiveMembers.parse("foo".to_slice).should eq SpecEnumWithCaseSensitiveMembers::FOO
+    SpecEnumWithCaseSensitiveMembers.parse("FOO".to_slice).should eq SpecEnumWithCaseSensitiveMembers::FOO
+    SpecEnumWithCaseSensitiveMembers.parse("Foo".to_slice).should eq SpecEnumWithCaseSensitiveMembers::FOO
+  end
+
   it ".parse?" do
     SpecEnum.parse?("Two").should eq(SpecEnum::Two)
     SpecEnum.parse?("Four").should be_nil
     SpecEnum.parse?("Fo-ur").should be_nil
+
+    SpecEnum.parse?("Two".to_slice).should eq(SpecEnum::Two)
+    SpecEnum.parse?("Four".to_slice).should be_nil
+    SpecEnum.parse?("Fo-ur".to_slice).should be_nil
   end
 
   it "clones" do

src/enum.cr

@@ -492,6 +492,10 @@ abstract struct Enum
     parse?(string) || raise ArgumentError.new("Unknown enum #{self} value: #{string}")
   end
 
+  def self.parse(slice : Bytes) : self
+    parse?(slice) || raise ArgumentError.new("Unknown enum #{self} value: #{slice}")
+  end
+
   # Returns the enum member that has the given name, or
   # `nil` if no such member exists. The comparison is made by using
   # `String#camelcase` and `String#downcase` between *string* and
@@ -508,6 +512,10 @@ abstract struct Enum
   #
   # If multiple members match the same normalized string, the first one is returned.
   def self.parse?(string : String) : self?
+    parse? string.to_slice
+  end
+
+  def self.parse?(slice : Bytes) : self?
     {% begin %}
       # FIXME: There is no `StringLiteral#bytesize` or any other adequate means
       # to figure out how much space we actually need. Maybe some regex could
@@ -520,14 +528,14 @@ abstract struct Enum
       {% max_size = @type.constants.map(&.size).sort.last %}
       buffer = uninitialized UInt8[{{ max_size * 4 + 1 }}]
       appender = buffer.to_unsafe.appender
-      char_counter = 0
-      string.each_char do |char|
-        next if char == '-' || char == '_'
-        char_counter += 1
-        return nil if char_counter > {{max_size}}
-        char.downcase &.each_byte do |byte|
-          appender << byte
-        end
+      byte_counter = 0
+      slice.each do |byte|
+        next if byte == '-'.ord || byte == '_'.ord
+        byte_counter += 1
+        return nil if byte_counter > {{max_size}}
+        # Setting the 6th bit on an alphabetical ASCII byte is effectively a
+        # downcase.
+        appender << ('A'.ord <= byte <= 'Z'.ord ? byte | 0x20_u8 : byte)
       end
       # Temporarily map all constants to their normalized value in order to
       # avoid duplicates in the `case` conditions.