erlang-etf 1.0.0

data/lib/erlang/etf/extensions/float.rb

@@ -0,0 +1,20 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      module Float
+
+        def __erlang_type__
+          :new_float
+        end
+
+        def __erlang_evolve__
+          ETF::NewFloat.new(self)
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/hash.rb

@@ -0,0 +1,32 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      #
+      # dictionary {bert, dict, KeysAndValues}
+      #
+      # Dictionaries (hash tables) are expressed via an array of 2-tuples representing the key/value pairs.
+      # The KeysAndValues array is mandatory, such that an empty dict is expressed as {bert, dict, []}.
+      # Keys and values may be any term.
+      # For example, {bert, dict, [{name, <<"Tom">>}, {age, 30}]}.
+      #
+      # See: http://bert-rpc.org/
+      #
+      module Hash
+
+        def __erlang_type__
+          :bert_dict
+        end
+
+        def __erlang_evolve__
+          ::Erlang::Tuple[:bert, :dict, map do |(key, value)|
+            ::Erlang::Tuple[key, value]
+          end].__erlang_evolve__
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/integer.rb

@@ -0,0 +1,48 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      module Integer
+
+        UINT8_MIN = 0.freeze
+        UINT8_MAX = (+(1 << 8) - 1).freeze
+
+        INT32_MIN = (-(1 << 31) + 1).freeze
+        INT32_MAX = (+(1 << 31) - 1).freeze
+
+        SMALL_BIG_N_MAX = 255.freeze
+
+        def __erlang_type__
+          if self >= UINT8_MIN and self <= UINT8_MAX
+            :small_integer
+          elsif self >= INT32_MIN and self <= INT32_MAX
+            :integer
+          else
+            n = (abs.to_s(2).bytesize / 8.0).ceil
+            if n <= SMALL_BIG_N_MAX
+              :small_big
+            else
+              :large_big
+            end
+          end
+        end
+
+        def __erlang_evolve__
+          case __erlang_type__
+          when :small_integer
+            ETF::SmallInteger.new(self)
+          when :integer
+            ETF::Integer.new(self)
+          when :small_big
+            ETF::SmallBig.new(self)
+          when :large_big
+            ETF::LargeBig.new(self)
+          end
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/nil_class.rb

@@ -0,0 +1,29 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      #
+      # nil {bert, nil}
+      #
+      # Erlang equates nil with the empty array [] while other languages do not.
+      # Even though NIL appears as a primitive in the serialization specification, BERT only uses it to represent the empty array.
+      # In order to be language agnostic, nil is encoded as a separate complex type to allow for disambiguation.
+      #
+      # See: http://bert-rpc.org/
+      #
+      module NilClass
+
+        def __erlang_type__
+          :bert_nil
+        end
+
+        def __erlang_evolve__
+          ::Erlang::Tuple[:bert, :nil].__erlang_evolve__
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/object.rb

@@ -0,0 +1,24 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      module Object
+
+        def __erlang_type__
+          raise NotImplementedError, "#__erlang_type__ undefined for #{inspect} of class #{self.class}"
+        end
+
+        def __erlang_evolve__
+          raise NotImplementedError, "#__erlang_evolve__ undefined for #{inspect} of class #{self.class}"
+        end
+
+        def __erlang_dump__(buffer)
+          __erlang_evolve__.serialize(buffer)
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/regexp.rb

@@ -0,0 +1,34 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      #
+      # regex {bert, regex, Source, Options}
+      #
+      # Regular expressions are expressed by their source binary and PCRE options.
+      # Options is a list of atoms representing the PCRE options.
+      # For example, {bert, regex, <<"^c(a*)t$">>, [caseless]} would represent a case insensitive regular epxression that would match "cat".
+      # See re:compile/2 for valid options.
+      #
+      # See: http://bert-rpc.org/
+      #
+      module Regexp
+
+        def __erlang_type__
+          :bert_regex
+        end
+
+        def __erlang_evolve__
+          opts = []
+          opts << :caseless  if (options & ::Regexp::IGNORECASE) != 0
+          opts << :extended  if (options & ::Regexp::EXTENDED)   != 0
+          opts << :multiline if (options & ::Regexp::MULTILINE)  != 0
+          ::Erlang::Tuple[:bert, :regex, source, opts].__erlang_evolve__
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/string.rb

@@ -0,0 +1,35 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      BINARY_ENCODING = Encoding.find("binary")
+      UTF8_ENCODING   = Encoding.find("utf-8")
+
+      module String
+
+        def __erlang_type__
+          :binary
+        end
+
+        def __erlang_evolve__
+          ETF::Binary.new(self)
+        end
+
+        def to_utf8_binary
+          encode(UTF8_ENCODING).force_encoding(BINARY_ENCODING)
+        rescue EncodingError
+          data = dup.force_encoding(UTF8_ENCODING)
+          raise unless data.valid_encoding?
+          data.force_encoding(BINARY_ENCODING)
+        end
+
+        def from_utf8_binary
+          force_encoding(UTF8_ENCODING).encode!
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/symbol.rb

@@ -0,0 +1,45 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      module Symbol
+
+        def __erlang_type__
+          if to_s.bytesize < 256
+            if to_s.ascii_only?
+              :small_atom
+            else
+              :small_atom_utf8
+            end
+          else
+            if to_s.ascii_only?
+              :atom
+            else
+              :atom_utf8
+            end
+          end
+        end
+
+        def __erlang_evolve__
+          case __erlang_type__
+          when :atom
+            ETF::Atom.new(to_s)
+          when :atom_utf8
+            ETF::AtomUTF8.new(to_s)
+          when :small_atom
+            ETF::SmallAtom.new(to_s)
+          when :small_atom_utf8
+            ETF::SmallAtomUTF8.new(to_s)
+          end
+        end
+
+        def to_utf8_binary
+          to_s.to_utf8_binary
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/time.rb

@@ -0,0 +1,29 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      #
+      # time {bert, time, Megaseconds, Seconds, Microseconds}
+      #
+      # The given time is the number of Megaseconds + Seconds + Microseconds elapsed since 00:00 GMT, January 1, 1970 (zero hour).
+      # For example, 2009-10-11 at 14:12:01 and 446,228 microseconds would be expressed as {bert, time, 1255, 295581, 446228}.
+      # In english, this is 1255 megaseconds (millions of seconds) + 295,581 seconds + 446,228 microseconds (millionths of a second) since zero hour.
+      #
+      # See: http://bert-rpc.org/
+      #
+      module Time
+
+        def __erlang_type__
+          :bert_time
+        end
+
+        def __erlang_evolve__
+          ::Erlang::Tuple[:bert, :time, to_i / 1_000_000, to_i % 1_000_000, usec].__erlang_evolve__
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/extensions/true_class.rb

@@ -0,0 +1,28 @@
+module Erlang
+  module ETF
+    module Extensions
+
+      #
+      # boolean {bert, true} or {bert, false}
+      #
+      # Erlang equates the true and false atoms with booleans while other languages do not have this behavior.
+      # To disambiguate these cases, booleans are expressed as their own complex type.
+      #
+      # See: http://bert-rpc.org/
+      #
+      module TrueClass
+
+        def __erlang_type__
+          :bert_boolean
+        end
+
+        def __erlang_evolve__
+          ::Erlang::Tuple[:bert, :true].__erlang_evolve__
+        end
+
+        module ClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/float.rb

@@ -0,0 +1,57 @@
+require 'bigdecimal'
+
+module Erlang
+  module ETF
+
+    #
+    # 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
+    # than necessary). To unpack the float use sscanf with format
+    # "%lf".
+    #
+    # This term is used in minor version 0 of the external format; it
+    # has been superseded by NEW_FLOAT_EXT .
+    #
+    class Float
+      include Term
+
+      FLOAT_STRING_FORMAT = "%.20e".freeze
+
+      uint8 :tag, always: Terms::FLOAT_EXT
+
+      string :float_string
+
+      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
+        end
+      end
+
+      undef deserialize_float_string
+      def deserialize_float_string(buffer)
+        self.float_string = buffer.read(31)
+      end
+
+      finalize
+
+      def initialize(float_string)
+        @float_string = float_string
+      end
+
+      def __ruby_evolve__
+        if float_string.is_a?(::BigDecimal)
+          float_string
+        else
+          ::BigDecimal.new(float_string.gsub("\000", ""))
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/fun.rb

@@ -0,0 +1,67 @@
+module Erlang
+  module ETF
+
+    #
+    # 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
+    #   process in which the fun was created.
+    # Module
+    #   is an encoded as an atom, using ATOM_EXT, SMALL_ATOM_EXT or
+    #   ATOM_CACHE_REF. This is the module that the fun is
+    #   implemented in.
+    # Index
+    #   is an integer encoded using SMALL_INTEGER_EXT or INTEGER_EXT.
+    #   It is typically a small index into the module's fun table.
+    # Uniq
+    #   is an integer encoded using SMALL_INTEGER_EXT or INTEGER_EXT.
+    #   Uniq is the hash value of the parse for the fun.
+    # Free vars
+    #   is NumFree number of terms, each one encoded according to its
+    #   type.
+    #
+    class Fun
+      include Term
+
+      uint8 :tag, always: Terms::FUN_EXT
+
+      uint16be :num_free, always: -> { free_vars.size }
+
+      term :pid # pid
+
+      term :mod # atom, small_atom
+
+      term :index # small_integer, integer
+
+      term :uniq # small_integer, integer
+
+      term :free_vars, type: :array
+
+      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)
+        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
+      end
+    end
+  end
+end