erlang-etf 1.1.1 → 2.0.0

data/lib/erlang/etf/atom.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 2   | Len
-    # --- | --- | --------
-    # 100 | Len | AtomName
+    # | 1   | 2   | Len      |
+    # | --- | --- | -------- |
+    # | 100 | Len | AtomName |
     #
     # An atom is stored with a 2 byte unsigned length in big-endian
     # order, followed by `Len` numbers of 8 bit Latin1 characters that
@@ -17,55 +17,35 @@ module Erlang
     # [`ATOM_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#ATOM_EXT
     #
     class Atom
-      include Term
-
-      uint8 :tag, always: Terms::ATOM_EXT
-
-      uint16be :len, default: 0 do
-        string :atom_name
-      end
-
-      undef deserialize_atom_name
-      # @private
-      def deserialize_atom_name(buffer)
-        self.atom_name = buffer.read(len).from_utf8_binary
+      include Erlang::ETF::Term
+
+      UINT16BE = Erlang::ETF::Term::UINT16BE
+
+      class << self
+        def [](term)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term) if not term.kind_of?(Erlang::Atom)
+          return new(term)
+        end
+
+        def erlang_load(buffer)
+          size, = buffer.read(2).unpack(UINT16BE)
+          data = buffer.read(size)
+          return new(Erlang::Atom[data])
+        end
       end
 
-      undef serialize_atom_name
-      # @private
-      def serialize_atom_name(buffer)
-        buffer << atom_name.to_utf8_binary
-      end
-
-      finalize
-
-      # Instantiate the new atom.
-      #
-      # @example Instantiate the atom.
-      #   Erlang::ETF::Atom.new("test")
-      #   # => #<Erlang::ETF::Atom @tag=100 @len=4 @atom_name="test">
-      #
-      # @param [ ::String ] atom_name The `AtomName` as a string.
-      #
-      # @since 1.0.0
-      def initialize(atom_name)
-        @atom_name = atom_name
-        @len = atom_name.to_s.bytesize
+      def initialize(term)
+        raise ArgumentError, "term must be of type Erlang::Atom" if not term.kind_of?(Erlang::Atom)
+        @term = term
       end
 
-      # Evolve to native ruby.
-      #
-      # @example Evolve to native ruby.
-      #   atom = Erlang::ETF::Atom.new("test")
-      #   atom.__ruby_evolve__
-      #   # => :test
-      #
-      # @return [ ::Symbol ] The `AtomName` as a symbol.
-      #
-      # @since 1.0.0
-      def __ruby_evolve__
-        atom_name.intern
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << ATOM_EXT
+        buffer << [@term.size].pack(UINT16BE)
+        buffer << Erlang::ETF::Term.binary_encoding(@term.data)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/atom_utf8.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 2   | Len
-    # --- | --- | --------
-    # 118 | Len | AtomName
+    # | 1   | 2   | Len      |
+    # | --- | --- | -------- |
+    # | 118 | Len | AtomName |
     #
     # An atom is stored with a 2 byte unsigned length in big-endian
     # order, followed by `Len` bytes containing the `AtomName` encoded
@@ -15,55 +15,35 @@ module Erlang
     # [`ATOM_UTF8_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#ATOM_UTF8_EXT
     #
     class AtomUTF8
-      include Term
-
-      uint8 :tag, always: Terms::ATOM_UTF8_EXT
-
-      uint16be :len, default: 0 do
-        string :atom_name
-      end
-
-      undef deserialize_atom_name
-      # @private
-      def deserialize_atom_name(buffer)
-        self.atom_name = buffer.read(len).from_utf8_binary
+      include Erlang::ETF::Term
+
+      UINT16BE = Erlang::ETF::Term::UINT16BE
+
+      class << self
+        def [](term)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term) if not term.kind_of?(Erlang::Atom)
+          return new(term)
+        end
+
+        def erlang_load(buffer)
+          size, = buffer.read(2).unpack(UINT16BE)
+          data = buffer.read(size)
+          return new(Erlang::Atom[data, utf8: true])
+        end
       end
 
-      undef serialize_atom_name
-      # @private
-      def serialize_atom_name(buffer)
-        buffer << atom_name.to_utf8_binary
-      end
-
-      finalize
-
-      # Instantiate the new UTF-8 atom.
-      #
-      # @example Instantiate the UTF-8 atom.
-      #   Erlang::ETF::AtomUTF8.new("Ωmega")
-      #   # => #<Erlang::ETF::AtomUTF8 @tag=118 @len=5 @atom_name="Ωmega">
-      #
-      # @param [ ::String ] atom_name The `AtomName` as a string.
-      #
-      # @since 1.0.0
-      def initialize(atom_name)
-        @atom_name = atom_name
-        @len = atom_name.to_s.bytesize
+      def initialize(term)
+        raise ArgumentError, "term must be of type Erlang::Atom" if not term.kind_of?(Erlang::Atom)
+        @term = term
       end
 
-      # Evolve to native ruby.
-      #
-      # @example Evolve to native ruby.
-      #   atom_utf8 = Erlang::ETF::AtomUTF8.new("Ωmega")
-      #   atom_utf8.__ruby_evolve__
-      #   # => :'Ωmega'
-      #
-      # @return [ ::Symbol ] The `AtomName` as a symbol.
-      #
-      # @since 1.0.0
-      def __ruby_evolve__
-        atom_name.intern
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << ATOM_UTF8_EXT
+        buffer << [@term.size].pack(UINT16BE)
+        buffer << Erlang::ETF::Term.binary_encoding(@term.data)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/binary.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4   | Len
-    # --- | --- | ----
-    # 109 | Len | Data
+    # | 1   | 4   | Len  |
+    # | --- | --- | ---- |
+    # | 109 | Len | Data |
     #
     # Binaries are generated with bit syntax expression or with
     # [`list_to_binary/1`], [`term_to_binary/1`], or as input from
@@ -19,33 +19,34 @@ module Erlang
     # [`BINARY_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#BINARY_EXT
     #
     class Binary
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::BINARY_EXT
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      uint32be :len, default: 0 do
-        string :data
-      end
-
-      undef deserialize_data
-      def deserialize_data(buffer)
-        self.data = buffer.read(len).from_utf8_binary
-      end
+      class << self
+        def [](term)
+          term = Erlang.from(term) if not term.kind_of?(Erlang::Binary)
+          return new(term)
+        end
 
-      undef serialize_data
-      def serialize_data(buffer)
-        buffer << data.to_utf8_binary
+        def erlang_load(buffer)
+          size, = buffer.read(4).unpack(UINT32BE)
+          data = buffer.read(size)
+          return new(Erlang::Binary[data])
+        end
       end
 
-      finalize
-
-      def initialize(data)
-        @data = data
+      def initialize(term)
+        raise ArgumentError, "term must be of type Erlang::Binary" if not term.kind_of?(Erlang::Binary)
+        @term = term
       end
 
-      def __ruby_evolve__
-        data
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << BINARY_EXT
+        buffer << [@term.bytesize].pack(UINT32BE)
+        buffer << Erlang::ETF::Term.binary_encoding(@term.data)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/bit_binary.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4   | 1    | Len
-    # --- | --- | ---- | ----
-    # 77  | Len | Bits | Data
+    # | 1   | 4   | 1    | Len  |
+    # | --- | --- | ---- | ---- |
+    # | 77  | Len | Bits | Data |
     #
     # This term represents a bitstring whose length in bits is not a
     # multiple of 8 (created using the bit syntax in R12B and later).
@@ -18,34 +18,42 @@ module Erlang
     # [`BIT_BINARY_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#BIT_BINARY_EXT
     #
     class BitBinary
-      include Term
-
-      uint8 :tag, always: Terms::BIT_BINARY_EXT
-
-      uint32be :len, always: -> { data.bytesize }
-
-      uint8 :bits
-
-      string :data, default: ""
-
-      undef serialize_data
-      def serialize_data(buffer)
-        buffer << data.to_utf8_binary
+      include Erlang::ETF::Term
+
+      UINT8    = Erlang::ETF::Term::UINT8
+      UINT32BE = Erlang::ETF::Term::UINT32BE
+      HEAD     = (UINT32BE + UINT8).freeze
+
+      class << self
+        def [](term)
+          term = Erlang.from(term) if not term.kind_of?(Erlang::Bitstring)
+          return new(term)
+        end
+
+        def erlang_load(buffer)
+          size, bits, = buffer.read(5).unpack(HEAD)
+          data = buffer.read(size)
+          if size > 0
+            data.setbyte(-1, data.getbyte(-1) >> (8 - bits))
+          end
+          return new(Erlang::Bitstring[data, bits: bits])
+        end
       end
 
-      deserialize do |buffer|
-        len, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
-        deserialize_bits(buffer)
-        self.data = buffer.read(len).from_utf8_binary
-        self
+      def initialize(term)
+        raise ArgumentError, "term must be of type Erlang::Bitstring" if not term.kind_of?(Erlang::Bitstring) and not term.kind_of?(Erlang::Binary)
+        @term = term
       end
 
-      finalize
-
-      def initialize(bits, data = "")
-        self.bits = bits
-        self.data = data
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << BIT_BINARY_EXT
+        buffer << [@term.bytesize, @term.bits].pack(HEAD)
+        buffer << Erlang::ETF::Term.binary_encoding(@term.data)
+        if @term.bytesize > 0
+          buffer.setbyte(-1, buffer.getbyte(-1) << (8 - @term.bits))
+        end
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/compressed.rb

@@ -4,17 +4,17 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4                | N
-    # --- | ---------------- | -------------------
-    # 80  | UncompressedSize | Zlib-compressedData
+    # | 1   | 4                | N                   |
+    # | --- | ---------------- | ------------------- |
+    # | 80  | UncompressedSize | Zlib-compressedData |
     #
-    # Uncompressed Size (unsigned 32 bit integer in big-endian 
-    # byte order) is the size of the data before it was compressed. 
+    # Uncompressed Size (unsigned 32 bit integer in big-endian
+    # byte order) is the size of the data before it was compressed.
     # The compressed data has the following format when it has been expanded:
     #
-    # 1    | Uncompressed Size
-    # ---- | -----------------
-    # Tag  | Data
+    # | 1    | Uncompressed Size |
+    # | ---- | ----------------- |
+    # | Tag  | Data              |
     #
     # (see [`External Term Format`] and [`term_to_binary/2`])
     #
@@ -22,45 +22,71 @@ module Erlang
     # [`term_to_binary/2`]: http://www.erlang.org/doc/man/erlang.html#term_to_binary-2
     #
     class Compressed
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::COMPRESSED
+      LEVEL_RANGE   = (0..9).freeze
+      LEVEL_DEFAULT = 6.freeze
 
-      uint32be :uncompressed_size, always: -> { data.serialize.bytesize }
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      term :data
+      class << self
+        def [](term, uncompressed_size = nil, compressed_data = nil, level: LEVEL_DEFAULT)
+          term = Erlang.from(term)
+          return new(term, uncompressed_size, compressed_data, level)
+        end
 
-      deserialize do |buffer|
-        uncompressed_size, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
-        compressed_data = buffer.read()
-        uncompressed_data = ::Zlib::Inflate.inflate(compressed_data)
-        if uncompressed_size == uncompressed_data.bytesize
-          deserialize_data(::StringIO.new(uncompressed_data))
-        else
-          raise ::Zlib::DataError, "UncompressedSize value did not match the size of the uncompressed data"
+        def erlang_load(buffer)
+          uncompressed_size, = buffer.read(4).unpack(UINT32BE)
+          compressed_data = buffer.read()
+          uncompressed_data = ::Zlib::Inflate.inflate(compressed_data)
+          if uncompressed_size == uncompressed_data.bytesize
+            term = Erlang.from(Erlang::ETF.read_term(StringIO.new(uncompressed_data)))
+            return new(term, uncompressed_size, compressed_data)
+          else
+            raise ::Zlib::DataError, "UncompressedSize value did not match the size of the uncompressed data"
+          end
         end
       end
 
-      undef serialize_data
-      def serialize_data(buffer)
-        uncompressed_data = data.serialize
-        compressed_data = ::Zlib::Deflate.deflate(uncompressed_data, @level)
-        buffer << compressed_data
+      def initialize(term, uncompressed_size = nil, compressed_data = nil, level = LEVEL_DEFAULT)
+        raise ArgumentError, "term must be of any type" if not Erlang.is_any(term)
+        @term = term
+        @uncompressed_size = uncompressed_size
+        @compressed_data = compressed_data
+        @level = LEVEL_RANGE.include?(level) ? level : LEVEL_DEFAULT
       end
 
-      finalize
-
-      LEVEL_RANGE = (0..9).freeze
-      LEVEL_DEFAULT = 6.freeze
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << COMPRESSED
+        if @uncompressed_size.nil? and @compressed_data.nil?
+          uncompressed_data = Erlang::ETF.write_term(@term, ::String.new.force_encoding(BINARY_ENCODING))
+          uncompressed_size = uncompressed_data.bytesize
+          compressed_data = ::Zlib::Deflate.deflate(uncompressed_data, @level)
+          buffer << [uncompressed_size].pack(UINT32BE)
+          buffer << Erlang::ETF::Term.binary_encoding(compressed_data)
+        else
+          buffer << [@uncompressed_size].pack(UINT32BE)
+          buffer << Erlang::ETF::Term.binary_encoding(@compressed_data)
+        end
+        return buffer
+      end
 
-      def initialize(data, level = LEVEL_DEFAULT)
-        @data = data
-        @level = LEVEL_RANGE.include?(level) ? level : LEVEL_DEFAULT
+      def inspect
+        if @uncompressed_size.nil? and @compressed_data.nil?
+          return "#{self.class}[#{@term.inspect}, level: #{@level.inspect}]"
+        else
+          return "#{self.class}[#{@term.inspect}, #{@uncompressed_size.inspect}, #{@compressed_data.inspect}, level: #{@level.inspect}]"
+        end
       end
 
-      def __ruby_evolve__
-        data.__ruby_evolve__
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@uncompressed_size, @compressed_data) if not @uncompressed_size.nil? or not @compressed_data.nil?
+        return pp.group(1, "#{self.class}[", ", level: #{@level.inspect}]") do
+          pp.breakable ''
+          pp.seplist(state) { |obj| obj.pretty_print(pp) }
+        end
       end
     end
   end
-end
+end