feat: Support other endian

Author: DanSnow

spec/binary_parser_spec.cr

@@ -2,58 +2,92 @@ require "./spec_helper"
 require "./fixture/*"
 
 describe BinaryParser do
+  describe "#load" do
+    it "load binary" do
+      parser = UInt32Parser.new.load(UInt32Fixture)
+      UInt32Fixture.rewind
+
+      expect(parser.value).to eq(42)
+    end
+
+    it "respect to IO::ByteFormat" do
+      parser = UInt32Parser.new.load(BigEndianUInt32Fixture, IO::ByteFormat::BigEndian)
+      BigEndianUInt32Fixture.rewind
+
+      expect(parser.value).to eq(42)
+    end
+  end
+
+  describe "#endian" do
+    it "work correct" do
+      parser = BigEndianParser.new.load(BigEndianUInt32Fixture)
+      BigEndianUInt32Fixture.rewind
+
+      expect(parser.value).to eq(42)
+    end
+  end
+
   describe "#uint64" do
     it "parse correct" do
       parser = UInt64Parser.new.load(UInt64Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#uint32" do
     it "parse correct" do
       parser = UInt32Parser.new.load(UInt32Fixture)
+      UInt32Fixture.rewind
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#uint16" do
     it "parse correct" do
       parser = UInt16Parser.new.load(UInt16Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#uint8" do
     it "parse correct" do
       parser = UInt8Parser.new.load(UInt8Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#int64" do
     it "parse correct" do
       parser = Int64Parser.new.load(Int64Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#int32" do
     it "parse correct" do
       parser = Int32Parser.new.load(Int32Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#int16" do
     it "parse correct" do
       parser = Int16Parser.new.load(Int16Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
 
   describe "#int8" do
     it "parse correct" do
       parser = Int8Parser.new.load(Int8Fixture)
+
       expect(parser.value).to eq(42)
     end
   end
@@ -62,13 +96,15 @@ describe BinaryParser do
     context "when fixed length" do
       it "parse correct" do
         parser = FixedArrayParser.new.load(FixedArrayFixture)
+
         expect(parser.arr).to eq([42, 43, 44, 45, 46])
       end
     end
 
     context "when variable length" do
       it "parse correct" do
         parser = VarArrayParser.new.load(VarArrayFixture)
+
         expect(parser.size).to eq(5)
         expect(parser.arr).to eq([42, 43, 44, 45, 46])
       end

spec/fixture/endian.cr

@@ -0,0 +1,11 @@
+require "../../src/binary_parser"
+
+class BigEndianParser < BinaryParser
+  endian :big
+  uint32 :value
+end
+
+
+BigEndianUInt32Fixture = IO::Memory.new(sizeof(UInt32))
+BigEndianUInt32Fixture.write_bytes(42u32, IO::ByteFormat::BigEndian)
+BigEndianUInt32Fixture.rewind

src/binary_parser.cr

@@ -18,27 +18,27 @@ require "./binary_parser/macros/*"
 class BinaryParser
   # Load from file with `filename`
   #
-  def load(filename : String)
+  def load(filename : String, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
     io = File.open(filename)
-    load(io)
+    load(io, format)
   end
 
   # Load from an IO object
   #
-  def load(io : IO)
+  def load(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
     {% for method in @type.methods %}
       {% if method.name.starts_with?("_read_") %}
-        {{method.name}}(io)
+        {{method.name}}(io, format)
       {% end %}
     {% end %}
     self
   end
 
   # Save to file with `filename`
   #
-  def save(filename : String)
+  def save(filename : String, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
     io = File.open(filename, "w")
-    write(io)
+    write(io, format)
   end
 
   # Convert to string
@@ -53,28 +53,26 @@ class BinaryParser
 
   # Write to an IO object
   #
-  def write(io : IO)
+  def write(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
     {% for method in @type.methods %}
       {% if method.name.starts_with?("_write_") %}
-        {{method.name}}(io)
+        {{method.name}}(io, format)
       {% end %}
     {% end %}
     self
   end
 
   # Support for `IO#read_bytes`
   #
-  # NOTE: Currently not respect to `IO::ByteFormat`
   def self.from_io(io : IO, format : IO::ByteFormat)
     ins = self.new
-    ins.load(io)
+    ins.load(io, format)
   end
 
   # Support for `IO#write_bytes`
   #
-  # NOTE: Currently not respect to `IO::ByteFormat`
   def to_io(io : IO, format : IO::ByteFormat)
-    write(io)
+    write(io, format)
   end
 end
 

src/binary_parser/macros/_primary_type.cr

@@ -19,12 +19,14 @@ class BinaryParser
     property! :{{name.id}}
     @{{name.id}} = 0{{suffix.id}}
 
-    def _read_{{name.id}}(io : IO)
-      @{{name.id}} = io.not_nil!.read_bytes({{type.id}}).as({{type.id}})
+    def _read_{{name.id}}(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
+      format = endian_config if format == IO::ByteFormat::SystemEndian
+      @{{name.id}} = io.not_nil!.read_bytes({{type.id}}, format).as({{type.id}})
     end
 
-    def _write_{{name.id}}(io : IO)
-      io.not_nil!.write_bytes(@{{name.id}}.not_nil!)
+    def _write_{{name.id}}(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
+      format = format == IO::ByteFormat::SystemEndian ? endian_config : format
+      io.not_nil!.write_bytes(@{{name.id}}.not_nil!, format)
     end
 
     def _size_static_{{name.id}}

src/binary_parser/macros/array.cr

@@ -26,24 +26,24 @@ class BinaryParser
     property! :{{name.id}}
     @{{name.id}} = [] of {{opt[:type]}}
 
-    def _read_{{name.id}}(io : IO)
+    def _read_{{name.id}}(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
       {% if opt[:count].is_a?(NumberLiteral) %}
         @{{name.id}} = Array({{opt[:type]}}).new({{opt[:count]}}) do
-          io.read_bytes({{opt[:type]}})
+          io.read_bytes({{opt[:type]}}, format)
         end
       {% elsif opt[:count].id != "eof" %}
         @{{name.id}} = Array({{opt[:type]}}).new(@{{opt[:count].id}}.not_nil!) do
-          io.read_bytes({{opt[:type]}})
+          io.read_bytes({{opt[:type]}}, format)
         end
       {% else %}
         @{{name.id}} = [] of {{opt[:type]}}
         # TODO: support :eof
       {% end %}
     end
 
-    def _write_{{name.id}}(io : IO)
+    def _write_{{name.id}}(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
       @{{name.id}}.not_nil!.each do |item|
-        io.write_bytes(item)
+        io.write_bytes(item, format)
       end
     end
 

src/binary_parser/macros/endian.cr

@@ -0,0 +1,28 @@
+class BinaryParser
+  @@endian : Symbol = :system
+
+  # Define what endian to use. `endian` can be either `:little` or  `:big`
+  #
+  # This macro should be place at the top of class, and can only call **zero** or **one** time.
+  #
+  # ```crystal
+  # endian
+  # ```
+  macro endian(type)
+    {% raise "Endian should be either :big or :little" if type != :big && type != :little %}
+    @@endian = {{type}}
+  end
+
+  private def endian_config
+    case @@endian
+    when :little
+      IO::ByteFormat::LittleEndian
+    when :big
+      IO::ByteFormat::BigEndian
+    when :system
+      IO::ByteFormat::SystemEndian
+    else # This shouldn't happen
+      raise "Endian type error"
+    end
+  end
+end

src/binary_parser/macros/string.cr

@@ -25,7 +25,7 @@ class BinaryParser
     @{{name.id}} = ""
 
     # TODO: Refactor
-    def _read_{{name.id}}(io : IO)
+    def _read_{{name.id}}(io : IO, _format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
       {% if opt[:count].is_a?(NumberLiteral) %}
         {% if opt[:count] != -1 %}
           buf = Slice(UInt8).new({{opt[:count]}})
@@ -45,7 +45,7 @@ class BinaryParser
       {% end %}
     end
 
-    def _write_{{name.id}}(io : IO)
+    def _write_{{name.id}}(io : IO, _format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
       {% if opt[:count].is_a?(NumberLiteral) %}
         {% if opt[:count] != -1 %}
           slice = Slice(UInt8).new({{opt[:count]}})

src/binary_parser/macros/type.cr

@@ -20,13 +20,13 @@ class BinaryParser
     property! :{{name.id}}
     @{{name.id}} = {{klass}}.new
 
-    def _read_{{name.id}}(io : IO)
+    def _read_{{name.id}}(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
       {% raise "Must inhert BinaryParser" if BinaryParser < klass.resolve %}
-      @{{name.id}} = io.read_bytes({{klass}}).as({{klass}})
+      @{{name.id}} = io.read_bytes({{klass}}, format).as({{klass}})
     end
 
-    def _write_{{name.id}}(io : IO)
-      io.write_bytes(@{{name.id}}.not_nil!)
+    def _write_{{name.id}}(io : IO, format : IO::ByteFormat = IO::ByteFormat::SystemEndian)
+      io.write_bytes(@{{name.id}}.not_nil!, format)
     end
 
     def _size_dyn_{{name.id}}