erlang-etf 1.1.1 → 2.0.0

data/lib/erlang/etf/export.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | N1     | N2       | N3
-    # --- | ------ | -------- | -----
-    # 113 | Module | Function | Arity
+    # | 1   | N1     | N2       | N3    |
+    # | --- | ------ | -------- | ----- |
+    # | 113 | Module | Function | Arity |
     #
     # This term is the encoding for external funs: `fun M:F/A`.
     #
@@ -22,31 +22,54 @@ module Erlang
     # [`EXPORT_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#EXPORT_EXT
     #
     class Export
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::EXPORT_EXT
+      class << self
+        def [](term, mod = nil, function = nil, arity = nil)
+          return new(term, mod, function, arity)
+        end
 
-      term :mod # atom, small_atom
-
-      term :function # atom, small_atom
+        def erlang_load(buffer)
+          mod      = Erlang::ETF.read_term(buffer)
+          function = Erlang::ETF.read_term(buffer)
+          arity    = Erlang::ETF.read_term(buffer)
+          term     = Erlang::Export[Erlang.from(mod), Erlang.from(function), Erlang.from(arity)]
+          return new(term, mod, function, arity)
+        end
+      end
 
-      term :arity # small_integer
+      def initialize(term, mod = nil, function = nil, arity = nil)
+        raise ArgumentError, "term must be of type Erlang::Export" if not term.kind_of?(Erlang::Export)
+        @term     = term
+        @mod      = mod
+        @function = function
+        @arity    = arity
+      end
 
-      finalize
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << EXPORT_EXT
+        Erlang::ETF.write_term(@mod      || @term.mod,      buffer)
+        Erlang::ETF.write_term(@function || @term.function, buffer)
+        Erlang::ETF.write_term(@arity    || @term.arity,    buffer)
+        return buffer
+      end
 
-      def initialize(mod, function, arity)
-        self.mod      = mod
-        self.function = function
-        self.arity    = arity
+      def inspect
+        if @mod.nil? and @function.nil? and @arity.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@mod.inspect}, #{@function.inspect}, #{@arity.inspect}]"
+        end
       end
 
-      def __ruby_evolve__
-        ::Erlang::Export.new(
-          mod.__ruby_evolve__,
-          function.__ruby_evolve__,
-          arity.__ruby_evolve__
-        )
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@mod, @function, @arity) if not @mod.nil? or not @function.nil? or not @arity.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/float.rb

@@ -1,12 +1,10 @@
-require 'bigdecimal'
-
 module Erlang
   module ETF
 
     #
-    # 1   | 31
-    # --- | ------------
-    # 99  | Float String
+    # | 1   | 31           |
+    # | --- | ------------ |
+    # | 99  | Float String |
     #
     # A float is stored in string format. the format used in sprintf
     # to format the float is "%.20e" (there are more bytes allocated
@@ -22,41 +20,47 @@ module Erlang
     # [`FLOAT_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#FLOAT_EXT
     #
     class Float
-      include Term
-
-      FLOAT_STRING_FORMAT = "%.20e".freeze
-
-      uint8 :tag, always: Terms::FLOAT_EXT
+      include Erlang::ETF::Term
 
-      string :float_string
+      class << self
+        def [](term, float_string = nil)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term)
+          return new(term, float_string)
+        end
 
-      undef serialize_float_string
-      def serialize_float_string(buffer)
-        if float_string.is_a?(::BigDecimal)
-          buffer << (FLOAT_STRING_FORMAT % float_string).ljust(31, "\000")
-        else
-          buffer << float_string
+        def erlang_load(buffer)
+          float_string = buffer.read(31)
+          term = Erlang::Float[float_string.byteslice(0, float_string.index("\0")), old: true]
+          return new(term, float_string)
         end
       end
 
-      undef deserialize_float_string
-      def deserialize_float_string(buffer)
-        self.float_string = buffer.read(31)
+      def initialize(term, float_string = nil)
+        raise ArgumentError, "term must be of type Erlang::Float" if not Erlang.is_float(term) or not term.old
+        @term         = term
+        @float_string = float_string
       end
 
-      finalize
-
-      def initialize(float_string)
-        @float_string = float_string
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << FLOAT_EXT
+        buffer << (@float_string || to_float_string)
+        return buffer
       end
 
-      def __ruby_evolve__
-        if float_string.is_a?(::BigDecimal)
-          float_string
+      def inspect
+        if @float_string.nil?
+          return "#{self.class}[#{@term.inspect}]"
         else
-          ::BigDecimal.new(float_string.gsub("\000", ""))
+          return "#{self.class}[#{@term.inspect}, #{@float_string.inspect}]"
         end
       end
+
+    private
+      def to_float_string
+        return @term.to_float_string.ljust(31, "\0")
+      end
+
     end
   end
-end
+end

data/lib/erlang/etf/fun.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4       | N1  | N2     | N3    | N4   | N5
-    # --- | ------- | --- | ------ | ----- | ---- | -------------
-    # 117 | NumFree | Pid | Module | Index | Uniq | Free vars ...
+    # | 1   | 4       | N1  | N2     | N3    | N4   | N5            |
+    # | --- | ------- | --- | ------ | ----- | ---- | ------------- |
+    # | 117 | NumFree | Pid | Module | Index | Uniq | Free vars ... |
     #
     # `Pid`
     # > is a process identifier as in [`PID_EXT`]. It represents the
@@ -38,44 +38,66 @@ module Erlang
     # [`FUN_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#FUN_EXT
     #
     class Fun
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::FUN_EXT
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      uint16be :num_free, always: -> { free_vars.size }
-
-      term :pid # pid
-
-      term :mod # atom, small_atom
+      class << self
+        def [](term, pid = nil, mod = nil, index = nil, uniq = nil, free_vars = nil)
+          return new(term, pid, mod, index, uniq, free_vars)
+        end
 
-      term :index # small_integer, integer
+        def erlang_load(buffer)
+          num_free, = buffer.read(4).unpack(UINT32BE)
+          pid       = Erlang::ETF.read_term(buffer)
+          mod       = Erlang::ETF.read_term(buffer)
+          index     = Erlang::ETF.read_term(buffer)
+          uniq      = 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[pid: Erlang.from(pid), mod: Erlang.from(mod), index: Erlang.from(index), uniq: Erlang.from(uniq), free_vars: Erlang.from(free_vars)]
+          return new(term, pid, mod, index, uniq, free_vars)
+        end
+      end
 
-      term :uniq # small_integer, integer
+      def initialize(term, pid = nil, mod = nil, index = nil, uniq = nil, free_vars = nil)
+        raise ArgumentError, "term must be of type Erlang::Function" if not term.kind_of?(Erlang::Function) or term.new_function?
+        @term      = term
+        @pid       = pid
+        @mod       = mod
+        @index     = index
+        @uniq      = uniq
+        @free_vars = free_vars
+      end
 
-      term :free_vars, type: :array
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << FUN_EXT
+        free_vars = @free_vars || @term.free_vars
+        num_free = free_vars.length
+        buffer << [num_free].pack(UINT32BE)
+        Erlang::ETF.write_term(@pid   || @term.pid,       buffer)
+        Erlang::ETF.write_term(@mod   || @term.mod,       buffer)
+        Erlang::ETF.write_term(@index || @term.index,     buffer)
+        Erlang::ETF.write_term(@uniq  || @term.uniq,      buffer)
+        num_free.times { |i| Erlang::ETF.write_term(free_vars[i], buffer) }
+        return buffer
+      end
 
-      deserialize do |buffer|
-        num_free, = buffer.read(BYTES_16).unpack(UINT16BE_PACK)
-        deserialize_pid(buffer)
-        deserialize_mod(buffer)
-        deserialize_index(buffer)
-        deserialize_uniq(buffer)
-        self.free_vars = []
-        num_free.times do
-          self.free_vars << Terms.deserialize(buffer)
+      def inspect
+        if @pid.nil? and @mod.nil? and @index.nil? and @uniq.nil? and @free_vars.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@pid.inspect}, #{@mod.inspect}, #{@index.inspect}, #{@uniq.inspect}, #{@free_vars.inspect}]"
         end
-        self
       end
 
-      finalize
-
-      def initialize(pid, mod, index, uniq, free_vars = [])
-        self.pid       = pid
-        self.mod       = mod
-        self.index     = index
-        self.uniq      = uniq
-        self.free_vars = free_vars
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@pid, @mod, @index, @uniq, @free_vars) if not @pid.nil? or not @mod.nil? or not @index.nil? or not @uniq.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/integer.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4
-    # --- | ---
-    # 98  | Int
+    # | 1   | 4   |
+    # | --- | --- |
+    # | 98  | Int |
     #
     # Signed 32 bit integer in big-endian format (i.e. MSB first)
     #
@@ -13,21 +13,33 @@ module Erlang
     # [`INTEGER_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#INTEGER_EXT
     #
     class Integer
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::INTEGER_EXT
+      INT32BE = Erlang::ETF::Term::INT32BE
 
-      int32be :int
+      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)
+          integer, = buffer.read(4).unpack(INT32BE)
+          return new(integer)
+        end
+      end
 
-      def initialize(int)
-        @int = int
+      def initialize(term)
+        raise ArgumentError, "term must be of type Integer" if not Erlang.is_integer(term)
+        @term = term
       end
 
-      def __ruby_evolve__
-        int
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << INTEGER_EXT
+        buffer << [@term].pack(INT32BE)
+        return buffer
       end
     end
   end
-end
+end

data/lib/erlang/etf/large_big.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4   | 1    | n
-    # --- | --- | ---- | ---------------
-    # 111 | n   | Sign | d(0) ... d(n-1)
+    # | 1   | 4   | 1    | n               |
+    # | --- | --- | ---- | --------------- |
+    # | 111 | n   | Sign | d(0) ... d(n-1) |
     #
     # Same as [`SMALL_BIG_EXT`] with the difference that the length
     # field is an unsigned 4 byte integer.
@@ -15,44 +15,38 @@ module Erlang
     # [`LARGE_BIG_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#LARGE_BIG_EXT
     #
     class LargeBig
-      include Term
-
-      uint8 :tag, always: Terms::LARGE_BIG_EXT
-
-      uint32be :n, default: 0 do
-        uint8 :sign, always: -> { (integer >= 0) ? 0 : 1 }
-        string :integer
+      include Erlang::ETF::Term
+
+      UINT8    = Erlang::ETF::Term::UINT8
+      UINT32BE = Erlang::ETF::Term::UINT32BE
+      HEAD     = (UINT32BE + 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(5).unpack(HEAD)
+          integer = Erlang::Binary.decode_unsigned(buffer.read(n), :little)
+          integer = -integer if sign == 1
+          return new(integer)
+        end
       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
-      end
-
-      undef after_serialize_n
-      def after_serialize_n(buffer)
-        buffer[@n_start, BYTES_32] = 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 << LARGE_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

data/lib/erlang/etf/large_tuple.rb

@@ -2,9 +2,9 @@ module Erlang
   module ETF
 
     #
-    # 1   | 4     | N
-    # --- | ----- | --------
-    # 105 | Arity | Elements
+    # | 1   | 4     | N        |
+    # | --- | ----- | -------- |
+    # | 105 | Arity | Elements |
     #
     # Same as [`SMALL_TUPLE_EXT`] with the exception that `Arity` is an
     # unsigned 4 byte integer in big endian format.
@@ -15,46 +15,57 @@ module Erlang
     # [`LARGE_TUPLE_EXT`]: http://erlang.org/doc/apps/erts/erl_ext_dist.html#LARGE_TUPLE_EXT
     #
     class LargeTuple
-      include Term
+      include Erlang::ETF::Term
 
-      uint8 :tag, always: Terms::LARGE_TUPLE_EXT
+      UINT32BE = Erlang::ETF::Term::UINT32BE
 
-      uint32be :arity, always: -> { elements.size }
-
-      term :elements, type: :array
+      class << self
+        def [](term, elements = nil)
+          return term if term.kind_of?(Erlang::ETF::Term)
+          term = Erlang.from(term)
+          return new(term, elements)
+        end
 
-      deserialize do |buffer|
-        arity, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
-        self.elements = []
-        arity.times do
-          self.elements << Terms.deserialize(buffer)
+        def erlang_load(buffer)
+          arity, = buffer.read(4).unpack(UINT32BE)
+          elements = Array.new(arity)
+          arity.times { |i| elements[i] = Erlang::ETF.read_term(buffer) }
+          tuple = Erlang::Tuple[*elements]
+          return new(tuple, elements)
         end
-        self
       end
 
-      finalize
-
-      def initialize(elements)
-        @elements = elements
+      def initialize(term, elements = nil)
+        raise ArgumentError, "term must be of type Tuple" if not Erlang.is_tuple(term)
+        @term = term
+        @elements = elements.freeze
       end
 
-      def serialize_header(buffer)
-        serialize_tag(buffer)
-        serialize_arity(buffer)
+      def erlang_dump(buffer = ::String.new.force_encoding(BINARY_ENCODING))
+        buffer << LARGE_TUPLE_EXT
+        elements = @elements || @term
+        arity = elements.size
+        buffer << [arity].pack(UINT32BE)
+        elements.each { |element| Erlang::ETF.write_term(element, buffer) }
+        return buffer
       end
 
-      def bert?
-        elements[0].respond_to?(:atom_name) &&
-        elements[0].atom_name == BERT_PREFIX
+      def inspect
+        if @elements.nil?
+          return super
+        else
+          return "#{self.class}[#{@term.inspect}, #{@elements.inspect}]"
+        end
       end
 
-      def __ruby_evolve__
-        if bert?
-          ::Erlang::ETF::BERT.evolve(self)
-        else
-          ::Erlang::Tuple[*elements.map(&:__ruby_evolve__)]
+      def pretty_print(pp)
+        state = [@term]
+        state.push(@elements) if not @elements.nil?
+        return pp.group(1, "#{self.class}[", "]") do
+          pp.breakable ''
+          pp.seplist(state) { |obj| obj.pretty_print(pp) }
         end
       end
     end
   end
-end
+end