erlang-etf 1.0.0

data/lib/erlang/etf/port.rb

@@ -0,0 +1,34 @@
+module Erlang
+  module ETF
+
+    #
+    # 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
+    # not allowed across node boundaries. The Creation works just like
+    # in REFERENCE_EXT.
+    #
+    class Port
+      include Term
+
+      uint8 :tag, always: Terms::PORT_EXT
+
+      term :node
+
+      uint32be :id, maximum: (1 << 28) - 1
+
+      int8 :creation, maximum: (1 << 2) - 1
+
+      finalize
+
+      def initialize(node, id, creation)
+        @node     = node
+        @id       = id
+        @creation = creation
+      end
+    end
+  end
+end

data/lib/erlang/etf/reference.rb

@@ -0,0 +1,41 @@
+module Erlang
+  module ETF
+
+    #
+    # 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
+    # or ATOM_CACHE_REF. The ID field contains a big-endian unsigned
+    # integer, but should be regarded as uninterpreted data since this
+    # field is node specific. Creation is a byte containing a node
+    # serial number that makes it possible to separate old (crashed)
+    # nodes from a new one.
+    #
+    # In ID, only 18 bits are significant; the rest should be 0.
+    # In Creation, only 2 bits are significant; the rest should be 0.
+    # See NEW_REFERENCE_EXT.
+    #
+    class Reference
+      include Term
+
+      uint8 :tag, always: Terms::REFERENCE_EXT
+
+      term :node
+
+      uint32be :id, maximum: (1 << 18) - 1
+
+      int8 :creation, maximum: (1 << 2) - 1
+
+      finalize
+
+      def initialize(node, id, creation)
+        @node     = node
+        @id       = id
+        @creation = creation
+      end
+    end
+  end
+end

data/lib/erlang/etf/small_atom.rb

@@ -0,0 +1,48 @@
+module Erlang
+  module ETF
+
+    #
+    # 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.
+    # Longer atoms can be represented by ATOM_EXT.
+    #
+    # Note the SMALL_ATOM_EXT was introduced in erts version 5.7.2 and
+    # require an exchange of the DFLAG_SMALL_ATOM_TAGS distribution
+    # flag in the distribution handshake.
+    #
+    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
+      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
+      end
+
+      def __ruby_evolve__
+        atom_name.intern
+      end
+    end
+  end
+end

data/lib/erlang/etf/small_atom_utf8.rb

@@ -0,0 +1,44 @@
+module Erlang
+  module ETF
+
+    #
+    # 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
+    # encoded in UTF-8 can be represented using 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
+      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
+      end
+
+      def __ruby_evolve__
+        atom_name.intern
+      end
+    end
+  end
+end

data/lib/erlang/etf/small_big.rb

@@ -0,0 +1,59 @@
+module Erlang
+  module ETF
+
+    #
+    # 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
+    # stored with the LSB byte stored first. To calculate the integer
+    # the following formula can be used:
+    # B = 256
+    # (d0*B^0 + d1*B^1 + d2*B^2 + ... d(N-1)*B^(n-1))
+    #
+    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
+      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
+      end
+
+      def __ruby_evolve__
+        integer
+      end
+    end
+  end
+end

data/lib/erlang/etf/small_integer.rb

@@ -0,0 +1,29 @@
+module Erlang
+  module ETF
+
+    #
+    # 1  | 1
+    # -- | ---
+    # 97 | Int
+    #
+    # Unsigned 8 bit integer.
+    #
+    class SmallInteger
+      include Term
+
+      uint8 :tag, always: Terms::SMALL_INTEGER_EXT
+
+      uint8 :int
+
+      finalize
+
+      def initialize(int)
+        @int = int
+      end
+
+      def __ruby_evolve__
+        int
+      end
+    end
+  end
+end

data/lib/erlang/etf/small_tuple.rb

@@ -0,0 +1,56 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 1     | N
+    # --- | ----- | --------
+    # 104 | Arity | Elements
+    #
+    # SMALL_TUPLE_EXT encodes a tuple. The Arity field is an unsigned
+    # byte that determines how many element that follows in the
+    # Elements section.
+    #
+    class SmallTuple
+      include Term
+
+      uint8 :tag, always: Terms::SMALL_TUPLE_EXT
+
+      uint8 :arity, always: -> { elements.size }
+
+      term :elements, type: :array
+
+      deserialize do |buffer|
+        arity, = buffer.read(BYTES_8).unpack(UINT8_PACK)
+        self.elements = []
+        arity.times do
+          self.elements << Terms.deserialize(buffer)
+        end
+        self
+      end
+
+      finalize
+
+      def initialize(elements)
+        @elements = elements
+      end
+
+      def serialize_header(buffer)
+        serialize_tag(buffer)
+        serialize_arity(buffer)
+      end
+
+      def bert?
+        elements[0].respond_to?(:atom_name) &&
+        elements[0].atom_name == BERT_PREFIX
+      end
+
+      def __ruby_evolve__
+        if bert?
+          ::Erlang::ETF::BERT.evolve(self)
+        else
+          ::Erlang::Tuple[*elements.map(&:__ruby_evolve__)]
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/string.rb

@@ -0,0 +1,46 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 2   | Len
+    # --- | --- | ----------
+    # 107 | Len | Characters
+    #
+    # String does NOT have a corresponding Erlang representation, but
+    # is an optimization for sending lists of bytes (integer in the
+    # range 0-255) more efficiently over the distribution. Since the
+    # Length field is an unsigned 2 byte integer (big endian),
+    # implementations must make sure that lists longer than 65535
+    # elements are encoded as LIST_EXT.
+    #
+    class String
+      include Term
+
+      uint8 :tag, always: Terms::STRING_EXT
+
+      uint16be :len, default: 0 do
+        string :characters
+      end
+
+      undef deserialize_characters
+      def deserialize_characters(buffer)
+        self.characters = buffer.read(len).from_utf8_binary
+      end
+
+      undef serialize_characters
+      def serialize_characters(buffer)
+        buffer << characters.to_utf8_binary
+      end
+
+      finalize
+
+      def initialize(characters)
+        @characters = characters
+      end
+
+      def __ruby_evolve__
+        ::Erlang::String.new(characters)
+      end
+    end
+  end
+end

data/lib/erlang/etf/term.rb

@@ -0,0 +1,101 @@
+module Erlang
+  module ETF
+    module Term
+
+      class << self
+
+        # Extends the including class with +ClassMethods+.
+        #
+        # @param [Class] subclass the inheriting class
+        def included(base)
+          super
+
+          base.send(:include, ::Binary::Protocol)
+          base.extend ClassMethods
+        end
+
+        private :included
+      end
+
+      BERT_PREFIX = "bert".freeze
+
+      BIN_LSB_PACK = 'b*'.freeze
+      BIN_MSB_PACK = 'B*'.freeze
+
+      module ClassMethods
+
+        def term(name, options = {})
+          if options.key?(:always)
+            __define_always__(name, options[:always])
+          else
+            if options.key?(:default)
+              __define_default__(name, options[:default])
+            else
+              attr_accessor name
+            end
+
+            if options[:type] == :array
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def deserialize_#{name}(buffer)
+                  raise NotImplementedError
+                end
+              RUBY
+            else
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def deserialize_#{name}(buffer)
+                  self.#{name} = Terms.deserialize(buffer)
+                end
+              RUBY
+            end
+          end
+
+          if options[:type] == :array
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def serialize_#{name}(buffer)
+                #{name}.each do |term|
+                  term.serialize(buffer)
+                end
+              end
+            RUBY
+          else
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def serialize_#{name}(buffer)
+                #{name}.serialize(buffer)
+              end
+            RUBY
+          end
+
+          serialization << :"serialize_#{name}"
+          fields << name
+        end
+
+      end
+
+      def ==(other)
+        self.class === other &&
+        self.class.fields.all? do |field|
+          __send__(field) == other.__send__(field)
+        end
+      end
+
+      def __erlang_type__
+        word = self.class.name.split('::').last.dup
+        word.gsub!('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(UTF8)(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word.intern
+      end
+
+      def __erlang_evolve__
+        self
+      end
+
+      def __ruby_evolve__
+        self
+      end
+    end
+  end
+end