erlang-etf 1.1.1 → 2.0.0

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

@@ -1,26 +0,0 @@
-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 FalseClass
-
-        def __erlang_type__
-          :bert_boolean
-        end
-
-        def __erlang_evolve__
-          ::Erlang::Tuple[:bert, :false].__erlang_evolve__
-        end
-
-      end
-    end
-  end
-end

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

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

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

@@ -1,30 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-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
-
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-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
-
-      end
-    end
-  end
-end

data/lib/erlang/etf/terms.rb

@@ -1,132 +0,0 @@
-module Erlang
-  module ETF
-
-    #
-    # See [`erts/emulator/beam/external.h`]
-    #
-    # [`erts/emulator/beam/external.h`]: https://github.com/erlang/otp/blob/master/erts/emulator/beam/external.h
-    #
-    module Terms
-      SMALL_INTEGER_EXT   =  97.freeze
-      INTEGER_EXT         =  98.freeze
-      FLOAT_EXT           =  99.freeze
-      ATOM_EXT            = 100.freeze
-      REFERENCE_EXT       = 101.freeze
-      PORT_EXT            = 102.freeze
-      PID_EXT             = 103.freeze
-      SMALL_TUPLE_EXT     = 104.freeze
-      LARGE_TUPLE_EXT     = 105.freeze
-      NIL_EXT             = 106.freeze
-      STRING_EXT          = 107.freeze
-      LIST_EXT            = 108.freeze
-      BINARY_EXT          = 109.freeze
-      SMALL_BIG_EXT       = 110.freeze
-      LARGE_BIG_EXT       = 111.freeze
-      NEW_REFERENCE_EXT   = 114.freeze
-      SMALL_ATOM_EXT      = 115.freeze
-      FUN_EXT             = 117.freeze
-      NEW_FUN_EXT         = 112.freeze
-      EXPORT_EXT          = 113.freeze
-      BIT_BINARY_EXT      =  77.freeze
-      NEW_FLOAT_EXT       =  70.freeze
-      ATOM_UTF8_EXT       = 118.freeze
-      SMALL_ATOM_UTF8_EXT = 119.freeze
-      MAP_EXT             = 116.freeze
-
-      DIST_HEADER             =  68.freeze # not implemented
-      ATOM_CACHE_REF          =  82.freeze # not implemented
-      ATOM_INTERNAL_REF2      =  73.freeze # not implemented
-      ATOM_INTERNAL_REF3      =  75.freeze # not implemented
-      BINARY_INTERNAL_REF     =  74.freeze # not implemented
-      BIT_BINARY_INTERNAL_REF =  76.freeze # not implemented
-      COMPRESSED              =  80.freeze
-    end
-  end
-end
-
-require "erlang/etf/term"
-require "erlang/etf/bert"
-
-require "erlang/etf/atom"
-require "erlang/etf/atom_utf8"
-require "erlang/etf/binary"
-require "erlang/etf/bit_binary"
-require "erlang/etf/compressed"
-require "erlang/etf/export"
-require "erlang/etf/float"
-require "erlang/etf/fun"
-require "erlang/etf/integer"
-require "erlang/etf/large_big"
-require "erlang/etf/large_tuple"
-require "erlang/etf/list"
-require "erlang/etf/map"
-require "erlang/etf/new_float"
-require "erlang/etf/new_fun"
-require "erlang/etf/new_reference"
-require "erlang/etf/nil"
-require "erlang/etf/pid"
-require "erlang/etf/port"
-require "erlang/etf/reference"
-require "erlang/etf/small_atom"
-require "erlang/etf/small_atom_utf8"
-require "erlang/etf/small_big"
-require "erlang/etf/small_integer"
-require "erlang/etf/small_tuple"
-require "erlang/etf/string"
-
-module Erlang
-  module ETF
-    module Terms
-      MAP = {}
-
-      MAP[SMALL_INTEGER_EXT]   = ETF::SmallInteger
-      MAP[INTEGER_EXT]         = ETF::Integer
-      MAP[FLOAT_EXT]           = ETF::Float
-      MAP[ATOM_EXT]            = ETF::Atom
-      MAP[REFERENCE_EXT]       = ETF::Reference
-      MAP[PORT_EXT]            = ETF::Port
-      MAP[PID_EXT]             = ETF::Pid
-      MAP[SMALL_TUPLE_EXT]     = ETF::SmallTuple
-      MAP[LARGE_TUPLE_EXT]     = ETF::LargeTuple
-      MAP[NIL_EXT]             = ETF::Nil
-      MAP[STRING_EXT]          = ETF::String
-      MAP[LIST_EXT]            = ETF::List
-      MAP[BINARY_EXT]          = ETF::Binary
-      MAP[SMALL_BIG_EXT]       = ETF::SmallBig
-      MAP[LARGE_BIG_EXT]       = ETF::LargeBig
-      MAP[NEW_REFERENCE_EXT]   = ETF::NewReference
-      MAP[SMALL_ATOM_EXT]      = ETF::SmallAtom
-      MAP[FUN_EXT]             = ETF::Fun
-      MAP[NEW_FUN_EXT]         = ETF::NewFun
-      MAP[EXPORT_EXT]          = ETF::Export
-      MAP[BIT_BINARY_EXT]      = ETF::BitBinary
-      MAP[NEW_FLOAT_EXT]       = ETF::NewFloat
-      MAP[ATOM_UTF8_EXT]       = ETF::AtomUTF8
-      MAP[SMALL_ATOM_UTF8_EXT] = ETF::SmallAtomUTF8
-      MAP[MAP_EXT]             = ETF::Map
-
-      # MAP[DIST_HEADER]             = NotImplementedError
-      # MAP[ATOM_CACHE_REF]          = NotImplementedError
-      # MAP[ATOM_INTERNAL_REF2]      = NotImplementedError
-      # MAP[ATOM_INTERNAL_REF3]      = NotImplementedError
-      # MAP[BINARY_INTERNAL_REF]     = NotImplementedError
-      # MAP[BIT_BINARY_INTERNAL_REF] = NotImplementedError
-      MAP[COMPRESSED]              = ETF::Compressed
-
-      MAP.freeze
-
-      def self.deserialize(buffer)
-        key, = buffer.read(1).unpack(::Binary::Protocol::UINT8_PACK)
-        if MAP.key?(key)
-          MAP[key].deserialize(buffer)
-        else
-          raise NotImplementedError, "unknown Erlang External Format tag #{key.inspect} (see http://erlang.org/doc/apps/erts/erl_ext_dist.html)"
-        end
-      end
-
-      def self.evolve(buffer)
-        deserialize(buffer).__ruby_evolve__
-      end
-    end
-  end
-end