erlang-etf 1.1.1 → 2.0.0

data/lib/erlang/etf/list.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4   | Len      | N1
-    # --- | --- | -------- | ----
-    # 108 | Len | Elements | Tail
+    # | 1   | 4      |          |      |
+    # | --- | ------ | -------- | ---- |
+    # | 108 | Length | Elements | Tail |
     #
     # `Length` is the number of elements that follows in the `Elements`
     # section. `Tail` is the final tail of the list; it is [`NIL_EXT`] for a
@@ -17,39 +17,69 @@ module Erlang
     # [`LIST_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#LIST_EXT
     #
     class List
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::LIST_EXT
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      uint32be :len, always: -> { elements.size }
-
-      term :elements, type: :array, allow_char: true
-      term :tail
+      class << self
+        def [](term, elements = nil, tail = nil)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term)
+          return new(term, elements, tail)
+        end
 
-      deserialize do |buffer|
-        len, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
-        self.elements = []
-        len.times do
-          self.elements << Terms.deserialize(buffer)
+        def erlang_load(buffer)
+          length, = buffer.read(4).unpack(UINT32BE)
+          elements = Array.new(length)
+          length.times { |i| elements[i] = Erlang::ETF.read_term(buffer) }
+          tail = Erlang::ETF.read_term(buffer)
+          return tail if length == 0
+          list = Erlang::List.from_enum(elements) + tail
+          return new(list, elements, tail)
         end
-        deserialize_tail(buffer)
-        self
       end
 
-      finalize
+      def initialize(term, elements = nil, tail = nil)
+        raise ArgumentError, "term must be of any type" if not Erlang.is_any(term)
+        @term = term
+        @elements = elements.freeze
+        @tail = tail.freeze
+      end
 
-      def initialize(elements, tail = Nil.new)
-        @elements = elements
-        @tail     = tail
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << LIST_EXT
+        elements = nil
+        tail = nil
+        if not Erlang.is_list(term)
+          elements = @elements || []
+          tail = @tail || @term
+        else
+          elements = @elements || (@term.improper? ? @term.to_proper_list : @term)
+          tail = @tail || (@term.improper? ? @term.last(true) : Erlang::Nil)
+        end
+        length = elements.size
+        buffer << [length].pack(UINT32BE)
+        elements.each { |element| Erlang::ETF.write_term(element, buffer) }
+        Erlang::ETF.write_term(tail, buffer)
+        return buffer
       end
 
-      def improper?
-        tail.class != ETF::Nil
+      def inspect
+        if @elements.nil? and @tail.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@elements.inspect}, #{@tail.inspect}]"
+        end
       end
 
-      def __ruby_evolve__
-        ::Erlang::List[*elements.map(&:__ruby_evolve__)].tail(tail.__ruby_evolve__)
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@elements, @tail) if not @elements.nil? or not @tail.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/map.rb

@@ -2,50 +2,80 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4    | N    | N
-    # --- | ---- | ---- | ------
-    # 116 | Size | Keys | Values
+    # | 1   | 4     | N     |
+    # | --- | ----- | ----- |
+    # | 116 | Arity | Pairs |
     #
-    # The Size specifies the number of keys and values that
-    # follows the size descriptor.
+    # `MAP_EXT` encodes a map. The `Arity` field is an unsigned 4 byte integer
+    # in big endian format that determines the number of key-value pairs in the
+    # map. Key and value pairs (`Ki => Vi`) are encoded in the `Pairs` section
+    # in the following order: `K1, V1, K2, V2,..., Kn, Vn`. Duplicate keys are
+    # **not allowed** within the same map.
     #
     # (see [`MAP_EXT`])
     #
     # [`MAP_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#MAP_EXT
     #
     class Map
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::MAP_EXT
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      uint32be :size, always: -> { keys.size }
-
-      term :keys,   type: :array
-      term :values, type: :array
-
-      deserialize do |buffer|
-        size, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
-        self.keys = []
-        size.times do
-          self.keys << Terms.deserialize(buffer)
+      class << self
+        def [](term, pairs = nil)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term)
+          return new(term, pairs)
         end
-        self.values = []
-        size.times do
-          self.values << Terms.deserialize(buffer)
+
+        def erlang_load(buffer)
+          arity, = buffer.read(4).unpack(UINT32BE)
+          pairs = Array.new(arity * 2)
+          (arity * 2).times { |i| pairs[i] = Erlang::ETF.read_term(buffer) }
+          map = Erlang::Map[*pairs]
+          return new(map, pairs)
         end
-        self
       end
 
-      finalize
+      def initialize(term, pairs = nil)
+        raise ArgumentError, "term must be of type Map" if not Erlang.is_map(term)
+        @term = term
+        @pairs = pairs.freeze
+      end
 
-      def initialize(keys, values)
-        @keys   = keys
-        @values = values
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << MAP_EXT
+        if @pairs
+          arity = @pairs.length.div(2)
+          buffer << [arity].pack(UINT32BE)
+          (arity * 2).times { |i| Erlang::ETF.write_term(@pairs[i], buffer) }
+        else
+          arity = @term.size
+          buffer << [arity].pack(UINT32BE)
+          @term.sort.each { |key, val|
+            Erlang::ETF.write_term(key, buffer)
+            Erlang::ETF.write_term(val, buffer)
+          }
+        end
+        return buffer
       end
 
-      def __ruby_evolve__
-        ::Erlang::Map[keys.map(&:__ruby_evolve__).zip(values.map(&:__ruby_evolve__))]
+      def inspect
+        if @pairs.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@pairs.inspect}]"
+        end
+      end
+
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@pairs) if not @pairs.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/new_float.rb

@@ -1,12 +1,10 @@
-require 'bigdecimal'
-
 module Erlang
   module ETF
 
     #
-    # 1   | 8
-    # --- | ----------
-    # 70  | IEEE Float
+    # | 1   | 8          |
+    # | --- | ---------- |
+    # | 70  | IEEE Float |
     #
     # A float is stored as 8 bytes in big-endian IEEE format.
     #
@@ -17,21 +15,34 @@ module Erlang
     # [`NEW_FLOAT_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#NEW_FLOAT_EXT
     #
     class NewFloat
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::NEW_FLOAT_EXT
+      DOUBLEBE = Erlang::ETF::Term::DOUBLEBE
 
-      doublebe :float
+      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)
+          float, = buffer.read(8).unpack(DOUBLEBE)
+          term = Erlang::Float[float]
+          return new(term)
+        end
+      end
 
-      def initialize(float)
-        @float = float
+      def initialize(term)
+        raise ArgumentError, "term must be of type Erlang::Float" if not Erlang.is_float(term) or term.old
+        @term = term
       end
 
-      def __ruby_evolve__
-        float
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << NEW_FLOAT_EXT
+        buffer << [@term.data].pack(DOUBLEBE)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/new_fun.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4    | 1     | 16   | 4     | 4       | N1     | N2       | N3      | N4  | N5
-    # --- | ---- | ----- | ---- | ----- | ------- | ------ | -------- | ------- | --- | ---------
-    # 112 | Size | Arity | Uniq | Index | NumFree | Module | Oldindex | OldUniq | Pid | Free Vars
+    # | 1   | 4    | 1     | 16   | 4     | 4       | N1     | N2       | N3      | N4  | N5        |
+    # | --- | ---- | ----- | ---- | ----- | ------- | ------ | -------- | ------- | --- | --------- |
+    # | 112 | Size | Arity | Uniq | Index | NumFree | Module | Oldindex | OldUniq | Pid | Free Vars |
     #
     # This is the new encoding of internal funs:
     #
@@ -60,61 +60,84 @@ module Erlang
     # [`NEW_FUN_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#NEW_FUN_EXT
     #
     class NewFun
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::NEW_FUN_EXT
+      UINT8     = Erlang::ETF::Term::UINT8
+      UINT32BE  = Erlang::ETF::Term::UINT32BE
+      UINT128BE = Erlang::ETF::Term::UINT128BE
+      HEAD      = (UINT32BE + UINT8 + UINT128BE + UINT32BE + UINT32BE).freeze
 
-      uint32be :size, default: 0, inclusive: true do
-        uint8 :arity
-        string :uniq
-        uint32be :index
-        uint32be :num_free, always: -> { free_vars.size }
-        term :mod
-        term :old_index
-        term :old_uniq
-        term :pid
-        term :free_vars, type: :array
+      class << self
+        def [](term, arity = nil, uniq = nil, index = nil, mod = nil, old_index = nil, old_uniq = nil, pid = nil, free_vars = nil)
+          return new(term, arity, uniq, index, mod, old_index, old_uniq, pid, free_vars)
+        end
+
+        def erlang_load(buffer)
+          _, arity, uniq_hi, uniq_lo, index, num_free = buffer.read(29).unpack(HEAD)
+          uniq = (uniq_hi << 64) + uniq_lo
+          mod       = Erlang::ETF.read_term(buffer)
+          old_index = Erlang::ETF.read_term(buffer)
+          old_uniq  = Erlang::ETF.read_term(buffer)
+          pid       = Erlang::ETF.read_term(buffer)
+          free_vars = Array.new(num_free); num_free.times { |i| free_vars[i] = Erlang::ETF.read_term(buffer) }
+          term      = Erlang::Function[arity: Erlang.from(arity), uniq: Erlang.from(uniq), index: Erlang.from(index), mod: Erlang.from(mod), old_index: Erlang.from(old_index), old_uniq: Erlang.from(old_uniq), pid: Erlang.from(pid), free_vars: Erlang.from(free_vars)]
+          return new(term, arity, uniq, index, mod, old_index, old_uniq, pid, free_vars)
+        end
       end
 
-      undef deserialize_uniq
-      def deserialize_uniq(buffer)
-        self.uniq = buffer.read(16).unpack(UINT8_PACK + '*')
+      def initialize(term, arity = nil, uniq = nil, index = nil, mod = nil, old_index = nil, old_uniq = nil, pid = nil, free_vars = nil)
+        raise ArgumentError, "term must be of type Erlang::Function" if not term.kind_of?(Erlang::Function) or not term.new_function?
+        @term      = term
+        @arity     = arity
+        @uniq      = uniq
+        @index     = index
+        @mod       = mod
+        @old_index = old_index
+        @old_uniq  = old_uniq
+        @pid       = pid
+        @free_vars = free_vars
       end
 
-      undef serialize_uniq
-      def serialize_uniq(buffer)
-        buffer << uniq.pack(UINT8_PACK + '*')
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << NEW_FUN_EXT
+        size      = 0
+        arity     = @arity     || @term.arity
+        uniq      = @uniq      || @term.uniq
+        index     = @index     || @term.index
+        free_vars = @free_vars || @term.free_vars
+        num_free  = free_vars.length
+        sizestart = buffer.bytesize
+        buffer << [size, arity, uniq >> 64, uniq, index, num_free].pack(HEAD)
+        Erlang::ETF.write_term(@mod       || @term.mod,       buffer)
+        Erlang::ETF.write_term(@old_index || @term.old_index, buffer)
+        Erlang::ETF.write_term(@old_uniq  || @term.old_uniq,  buffer)
+        Erlang::ETF.write_term(@pid       || @term.pid,       buffer)
+        num_free.times { |i| Erlang::ETF.write_term(free_vars[i], buffer) }
+        sizeend   = buffer.bytesize
+        size      = sizeend - sizestart
+        buffer.setbyte(sizestart + 0, size >> 24)
+        buffer.setbyte(sizestart + 1, size >> 16)
+        buffer.setbyte(sizestart + 2, size >> 8)
+        buffer.setbyte(sizestart + 3, size)
+        return buffer
       end
 
-      deserialize do |buffer|
-        deserialize_size(buffer)
-        deserialize_arity(buffer)
-        deserialize_uniq(buffer)
-        deserialize_index(buffer)
-        num_free, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
-        deserialize_mod(buffer)
-        deserialize_old_index(buffer)
-        deserialize_old_uniq(buffer)
-        deserialize_pid(buffer)
-        self.free_vars = []
-        num_free.times do
-          self.free_vars << Terms.deserialize(buffer)
+      def inspect
+        if @arity.nil? and @uniq.nil? and @index.nil? and @mod.nil? and @old_index.nil? and @old_uniq.nil? and @pid.nil? and @free_vars.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@arity.inspect}, #{@uniq.inspect}, #{@index.inspect}, #{@mod.inspect}, #{@old_index.inspect}, #{@old_uniq.inspect}, #{@pid.inspect}, #{@free_vars.inspect}]"
         end
-        self
       end
 
-      finalize
-
-      def initialize(arity, uniq, index, mod, old_index, old_uniq, pid, free_vars = [])
-        self.arity     = arity
-        self.uniq      = uniq
-        self.index     = index
-        self.mod       = mod
-        self.old_index = old_index
-        self.old_uniq  = old_uniq
-        self.pid       = pid
-        self.free_vars = free_vars
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@arity, @uniq, @index, @mod, @old_index, @old_uniq, @pid, @free_vars) if not @arity.nil? or not @uniq.nil? or not @index.nil? or not @mod.nil? or not @old_index.nil? or not @old_uniq.nil? or not @pid.nil? or not @free_vars.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/new_reference.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 2   | N    | 1        | N'
-    # --- | --- | ---- | -------- | ------
-    # 114 | Len | Node | Creation | ID ...
+    # | 1   | 2   | N    | 1        | N'     |
+    # | --- | --- | ---- | -------- | ------ |
+    # | 114 | Len | Node | Creation | ID ... |
     #
     # `Node` and `Creation` are as in [`REFERENCE_EXT`].
     #
@@ -29,36 +29,63 @@ module Erlang
     # [`NEW_REFERENCE_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#NEW_REFERENCE_EXT
     #
     class NewReference
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::NEW_REFERENCE_EXT
+      UINT8    = Erlang::ETF::Term::UINT8
+      UINT16BE = Erlang::ETF::Term::UINT16BE
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      uint16be :len, always: -> { ids.size }
-
-      term :node
-
-      int8 :creation, maximum: (1 << 2) - 1
-
-      uint32be :ids, type: :array, default: []
+      class << self
+        def [](term, node = nil, creation = nil, ids = nil)
+          return new(term, node, creation, ids)
+        end
 
-      deserialize do |buffer|
-        len, = buffer.read(BYTES_16).unpack(UINT16BE_PACK)
-        deserialize_node(buffer)
-        deserialize_creation(buffer)
-        self.ids = []
-        len.times do
-          self.ids << buffer.read(BYTES_32).unpack(UINT32BE_PACK).at(0)
+        def erlang_load(buffer)
+          length, = buffer.read(2).unpack(UINT16BE)
+          node = Erlang::ETF.read_term(buffer)
+          creation, *ids = buffer.read(1 + (4 * length)).unpack("#{UINT8}#{UINT32BE}#{length}")
+          term = Erlang::Reference[Erlang.from(node), Erlang.from(creation), Erlang.from(ids)]
+          return new(term, node, creation, ids)
         end
-        self
       end
 
-      finalize
-
-      def initialize(node, creation, ids = [])
+      def initialize(term, node = nil, creation = nil, ids = nil)
+        raise ArgumentError, "term must be of type Erlang::Reference" if not term.kind_of?(Erlang::Reference) or not term.new_reference?
+        @term     = term
         @node     = node
         @creation = creation
         @ids      = ids
       end
+
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << NEW_REFERENCE_EXT
+        ids = @ids || @term.ids
+        length = ids.size
+        buffer << [length].pack(UINT16BE)
+        Erlang::ETF.write_term(@node || @term.node, buffer)
+        buffer << [
+          @creation || @term.creation,
+          *ids
+        ].pack("#{UINT8}#{UINT32BE}#{length}")
+        return buffer
+      end
+
+      def inspect
+        if @node.nil? and @creation.nil? and @ids.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@node.inspect}, #{@creation.inspect}, #{@ids.inspect}]"
+        end
+      end
+
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@node, @creation, @ids) if not @node.nil? or not @creation.nil? or not @ids.nil?
+        return pp.group(1, "#{self.class}[", "]") do
+          pp.breakable ''
+          pp.seplist(state) { |obj| obj.pretty_print(pp) }
+        end
+      end
     end
   end
-end
+end