erlang-etf 1.1.1 → 2.0.0

data/lib/erlang/etf/nil.rb

@@ -13,15 +13,30 @@ module Erlang
     # [`NIL_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#NIL_EXT
     #
     class Nil
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::NIL_EXT
+      class << self
+        def [](term)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term)
+          return new(term)
+        end
 
-      finalize
+        def erlang_load(buffer)
+          term = Erlang::Nil
+          return new(term)
+        end
+      end
+
+      def initialize(term)
+        raise ArgumentError, "term must be of type Erlang::Nil" if not Erlang::Nil.equal?(term)
+        @term = term
+      end
 
-      def __ruby_evolve__
-        []
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << NIL_EXT
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/pid.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | N    | 4   | 4      | 1
-    # --- | ---- | --- | ------ | --------
-    # 103 | Node | ID  | Serial | Creation
+    # | 1   | N    | 4   | 4      | 1        |
+    # | --- | ---- | --- | ------ | -------- |
+    # | 103 | Node | ID  | Serial | Creation |
     #
     # Encode a process identifier object (obtained from [`spawn/3`] or
     # friends). The `ID` and `Creation` fields works just like in
@@ -18,34 +18,61 @@ module Erlang
     # [`PID_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#PID_EXT
     #
     class Pid
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::PID_EXT
+      UINT8    = Erlang::ETF::Term::UINT8
+      UINT32BE = Erlang::ETF::Term::UINT32BE
+      HEAD     = (UINT32BE + UINT32BE + UINT8).freeze
 
-      term :node
+      class << self
+        def [](term, node = nil, id = nil, serial = nil, creation = nil)
+          return new(term, node, id, serial, creation)
+        end
 
-      uint32be :id,     maximum: (1 << 15) - 1
-      uint32be :serial, maximum: (1 << 13) - 1
-
-      int8 :creation, maximum: (1 << 2) - 1
-
-      finalize
+        def erlang_load(buffer)
+          node = Erlang::ETF.read_term(buffer)
+          id, serial, creation = buffer.read(9).unpack(HEAD)
+          term = Erlang::Pid[Erlang.from(node), Erlang.from(id), Erlang.from(serial), Erlang.from(creation)]
+          return new(term, node, id, serial, creation)
+        end
+      end
 
-      def initialize(node, id, serial, creation)
+      def initialize(term, node = nil, id = nil, serial = nil, creation = nil)
+        raise ArgumentError, "term must be of type Erlang::Pid" if not term.kind_of?(Erlang::Pid)
+        @term     = term
         @node     = node
         @id       = id
         @serial   = serial
         @creation = creation
       end
 
-      def __ruby_evolve__
-        ::Erlang::Pid.new(
-          node.__ruby_evolve__,
-          id,
-          serial,
-          creation
-        )
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << PID_EXT
+        Erlang::ETF.write_term(@node || @term.node, buffer)
+        buffer << [
+          @id       || @term.id,
+          @serial   || @term.serial,
+          @creation || @term.creation
+        ].pack(HEAD)
+        return buffer
+      end
+
+      def inspect
+        if @node.nil? and @id.nil? and @serial.nil? and @creation.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@node.inspect}, #{@id.inspect}, #{@serial.inspect}, #{@creation.inspect}]"
+        end
+      end
+
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@node, @id, @serial, @creation) if not @node.nil? or not @id.nil? or not @serial.nil? or not @creation.nil?
+        return pp.group(1, "#{self.class}[", "]") do
+          pp.breakable ''
+          pp.seplist(state) { |obj| obj.pretty_print(pp) }
+        end
       end
     end
   end
-end
+end

data/lib/erlang/etf/port.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | N    | 4   | 1
-    # --- | ---- | --- | --------
-    # 102 | Node | ID  | Creation
+    # | 1   | N    | 4   | 1        |
+    # | --- | ---- | --- | -------- |
+    # | 102 | Node | ID  | Creation |
     #
     # Encode a port object (obtained form [`open_port/2`]). The `ID` is a
     # node specific identifier for a local port. Port operations are
@@ -18,23 +18,59 @@ module Erlang
     # [`PORT_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#PORT_EXT
     #
     class Port
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::PORT_EXT
+      UINT8    = Erlang::ETF::Term::UINT8
+      UINT32BE = Erlang::ETF::Term::UINT32BE
+      HEAD     = (UINT32BE + UINT8).freeze
 
-      term :node
+      class << self
+        def [](term, node = nil, id = nil, creation = nil)
+          return new(term, node, id, creation)
+        end
 
-      uint32be :id, maximum: (1 << 28) - 1
-
-      int8 :creation, maximum: (1 << 2) - 1
-
-      finalize
+        def erlang_load(buffer)
+          node = Erlang::ETF.read_term(buffer)
+          id, creation = buffer.read(5).unpack(HEAD)
+          term = Erlang::Port[Erlang.from(node), Erlang.from(id), Erlang.from(creation)]
+          return new(term, node, id, creation)
+        end
+      end
 
-      def initialize(node, id, creation)
+      def initialize(term, node = nil, id = nil, creation = nil)
+        raise ArgumentError, "term must be of type Erlang::Port" if not term.kind_of?(Erlang::Port)
+        @term     = term
         @node     = node
         @id       = id
         @creation = creation
       end
+
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << PORT_EXT
+        Erlang::ETF.write_term(@node || @term.node, buffer)
+        buffer << [
+          @id       || @term.id,
+          @creation || @term.creation
+        ].pack(HEAD)
+        return buffer
+      end
+
+      def inspect
+        if @node.nil? and @id.nil? and @creation.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@node.inspect}, #{@id.inspect}, #{@creation.inspect}]"
+        end
+      end
+
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@node, @id, @creation) if not @node.nil? or not @id.nil? or not @creation.nil?
+        return pp.group(1, "#{self.class}[", "]") do
+          pp.breakable ''
+          pp.seplist(state) { |obj| obj.pretty_print(pp) }
+        end
+      end
     end
   end
-end
+end

data/lib/erlang/etf/reference.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | N    | 4   | 1
-    # --- | ---- | --- | --------
-    # 101 | Node | ID  | Creation
+    # | 1   | N    | 4   | 1        |
+    # | --- | ---- | --- | -------- |
+    # | 101 | Node | ID  | Creation |
     #
     # Encode a reference object (an object generated with [`make_ref/0`]).
     # The `Node` term is an encoded atom, i.e. [`ATOM_EXT`], [`SMALL_ATOM_EXT`]
@@ -28,23 +28,59 @@ module Erlang
     # [`REFERENCE_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#REFERENCE_EXT
     #
     class Reference
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::REFERENCE_EXT
+      UINT8    = Erlang::ETF::Term::UINT8
+      UINT32BE = Erlang::ETF::Term::UINT32BE
+      HEAD     = (UINT32BE + UINT8).freeze
 
-      term :node
+      class << self
+        def [](term, node = nil, id = nil, creation = nil)
+          return new(term, node, id, creation)
+        end
 
-      uint32be :id, maximum: (1 << 18) - 1
-
-      int8 :creation, maximum: (1 << 2) - 1
-
-      finalize
+        def erlang_load(buffer)
+          node = Erlang::ETF.read_term(buffer)
+          id, creation = buffer.read(5).unpack(HEAD)
+          term = Erlang::Reference[Erlang.from(node), Erlang.from(creation), Erlang.from(id)]
+          return new(term, node, id, creation)
+        end
+      end
 
-      def initialize(node, id, creation)
+      def initialize(term, node = nil, id = nil, creation = nil)
+        raise ArgumentError, "term must be of type Erlang::Reference" if not term.kind_of?(Erlang::Reference) or term.new_reference?
+        @term     = term
         @node     = node
         @id       = id
         @creation = creation
       end
+
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << REFERENCE_EXT
+        Erlang::ETF.write_term(@node || @term.node, buffer)
+        buffer << [
+          @id       || @term.id,
+          @creation || @term.creation
+        ].pack(HEAD)
+        return buffer
+      end
+
+      def inspect
+        if @node.nil? and @id.nil? and @creation.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@node.inspect}, #{@id.inspect}, #{@creation.inspect}]"
+        end
+      end
+
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@node, @id, @creation) if not @node.nil? or not @id.nil? or not @creation.nil?
+        return pp.group(1, "#{self.class}[", "]") do
+          pp.breakable ''
+          pp.seplist(state) { |obj| obj.pretty_print(pp) }
+        end
+      end
     end
   end
-end
+end

data/lib/erlang/etf/small_atom.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 1   | Len
-    # --- | --- | --------
-    # 115 | Len | AtomName
+    # | 1   | 1   | Len      |
+    # | --- | --- | -------- |
+    # | 115 | Len | AtomName |
     #
     # An atom is stored with a 1 byte unsigned length, followed by `Len`
     # numbers of 8 bit Latin1 characters that forms the `AtomName`.
@@ -22,34 +22,38 @@ module Erlang
     # [`SMALL_ATOM_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#SMALL_ATOM_EXT
     #
     class SmallAtom
-      include Term
-
-      uint8 :tag, always: Terms::SMALL_ATOM_EXT
-
-      uint8 :len, default: 0 do
-        string :atom_name
-      end
-
-      undef deserialize_atom_name
-      def deserialize_atom_name(buffer)
-        self.atom_name = buffer.read(len).from_utf8_binary
+      include Erlang::ETF::Term
+
+      UINT8 = Erlang::ETF::Term::UINT8
+
+      class << self
+        def [](term)
+          return term if term.kind_of?(Erlang::ETF::Atom)
+          return term if term.kind_of?(Erlang::ETF::AtomUTF8)
+          return term if term.kind_of?(Erlang::ETF::SmallAtom)
+          return term if term.kind_of?(Erlang::ETF::SmallAtomUTF8)
+          term = Erlang.from(term) if not term.kind_of?(Erlang::Atom)
+          return new(term)
+        end
+
+        def erlang_load(buffer)
+          size, = buffer.read(1).unpack(UINT8)
+          data = buffer.read(size)
+          return new(Erlang::Atom[data])
+        end
       end
 
-      undef serialize_atom_name
-      def serialize_atom_name(buffer)
-        buffer << atom_name.to_utf8_binary
-      end
-
-      finalize
-
-      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
 
-      def __ruby_evolve__
-        atom_name.intern
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << SMALL_ATOM_EXT
+        buffer << [@term.size].pack(UINT8)
+        buffer << Erlang::Terms.binary_encoding(@term.data)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/small_atom_utf8.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 1   | Len
-    # --- | --- | --------
-    # 119 | Len | AtomName
+    # | 1   | 1   | Len      |
+    # | --- | --- | -------- |
+    # | 119 | Len | AtomName |
     #
     # An atom is stored with a 1 byte unsigned length, followed by `Len`
     # bytes containing the `AtomName` encoded in UTF-8. Longer atoms
@@ -16,34 +16,38 @@ module Erlang
     # [`SMALL_ATOM_UTF8_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#SMALL_ATOM_UTF8_EXT
     #
     class SmallAtomUTF8
-      include Term
-
-      uint8 :tag, always: Terms::SMALL_ATOM_UTF8_EXT
-
-      uint8 :len, default: 0 do
-        string :atom_name
-      end
-
-      undef deserialize_atom_name
-      def deserialize_atom_name(buffer)
-        self.atom_name = buffer.read(len).from_utf8_binary
+      include Erlang::ETF::Term
+
+      UINT8 = Erlang::ETF::Term::UINT8
+
+      class << self
+        def [](term)
+          return term if term.kind_of?(Erlang::ETF::Atom)
+          return term if term.kind_of?(Erlang::ETF::AtomUTF8)
+          return term if term.kind_of?(Erlang::ETF::SmallAtom)
+          return term if term.kind_of?(Erlang::ETF::SmallAtomUTF8)
+          term = Erlang.from(term) if not term.kind_of?(Erlang::Atom)
+          return new(term)
+        end
+
+        def erlang_load(buffer)
+          size, = buffer.read(1).unpack(UINT8)
+          data = buffer.read(size)
+          return new(Erlang::Atom[data, utf8: true])
+        end
       end
 
-      undef serialize_atom_name
-      def serialize_atom_name(buffer)
-        buffer << atom_name.to_utf8_binary
-      end
-
-      finalize
-
-      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
 
-      def __ruby_evolve__
-        atom_name.intern
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << SMALL_ATOM_UTF8_EXT
+        buffer << [@term.size].pack(UINT8)
+        buffer << Erlang::Terms.binary_encoding(@term.data)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/small_big.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 1   | 1    | n
-    # --- | --- | ---- | ---------------
-    # 110 | n   | Sign | d(0) ... d(n-1)
+    # | 1   | 1   | 1    | n               |
+    # | --- | --- | ---- | --------------- |
+    # | 110 | n   | Sign | d(0) ... d(n-1) |
     #
     # Bignums are stored in unary form with a `Sign` byte that is 0 if
     # the binum is positive and 1 if is negative. The digits are
@@ -22,46 +22,37 @@ module Erlang
     # [`SMALL_BIG_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#SMALL_BIG_EXT
     #
     class SmallBig
-      include Term
-
-      uint8 :tag, always: Terms::SMALL_BIG_EXT
-
-      uint8 :n, default: 0 do
-        uint8 :sign, always: -> { (integer >= 0) ? 0 : 1 }
-        string :integer
-      end
-
-      undef serialize_integer
-
-      def serialize_integer(buffer)
-        start = buffer.bytesize
-        buffer << [integer.abs.to_s(2).reverse!].pack(BIN_LSB_PACK)
-        self.n = buffer.bytesize - start
-        buffer
+      include Erlang::ETF::Term
+
+      UINT8 = Erlang::ETF::Term::UINT8
+      HEAD  = (UINT8 + UINT8).freeze
+
+      class << self
+        def [](term)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term)
+          return new(term)
+        end
+
+        def erlang_load(buffer)
+          n, sign, = buffer.read(2).unpack(HEAD)
+          integer = Erlang::Binary.decode_unsigned(buffer.read(n), :little)
+          integer = -integer if sign == 1
+          return new(integer)
+        end
       end
 
-      undef after_serialize_n
-
-      def after_serialize_n(buffer)
-        buffer[@n_start, BYTES_8] = serialize_n ""
-      end
-
-      deserialize do |buffer|
-        deserialize_n(buffer)
-        sign, = buffer.read(BYTES_8).unpack(UINT8_PACK)
-        self.integer = buffer.read(n).unpack(BIN_LSB_PACK).at(0).reverse!.to_i(2) * ((sign == 0) ? 1 : -1)
-        self
-      end
-
-      finalize
-
-      def initialize(integer)
-        @integer = integer
+      def initialize(term)
+        raise ArgumentError, "term must be of type Integer" if not Erlang.is_integer(term)
+        @term = term
       end
 
-      def __ruby_evolve__
-        integer
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << SMALL_BIG_EXT
+        buffer << [Erlang::ETF.intlog2div8(@term), (@term < 0) ? 1 : 0].pack(HEAD)
+        buffer << Erlang::Binary.encode_unsigned(@term.abs, :little)
+        return buffer
       end
     end
   end
-end
+end