erlang-etf 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 320c12034e0d50d1f92aeeadcc0042a121f972de
-  data.tar.gz: c739e92472dbdef20ab555ddfb53b8404a7100d0
+  metadata.gz: 3781a7262d7a19086a4fd9bdf06b8af1c40b5fc7
+  data.tar.gz: 2fe7d74a025640903e188be88a465174685a6d6e
 SHA512:
-  metadata.gz: d793115fb5b5bfe1694c0a23a0b0819435e206c91f8c55876cdbd0327e4bec433f0eafa9a4893e6e292832fb0a698e63c95db38c56d0a69857c3a87e4f2e34bd
-  data.tar.gz: 6d05ec4e5619e8eedc9d95dadb904b2b4d6aaef75c857572f5aa21cb9e2573ab37e88e09d31336ef7b6d46d14d7b29b36f5ed7e2be3dc0f826031503bc5bdd89
+  metadata.gz: '042448d3a9c743edddb837bf2677f9ee9ec44c682851d160b2f6fa2f5ce788ab8df9b0159227324baee69a5d96a7d009460fefad460a1962c8de96040ce624ff'
+  data.tar.gz: bc027fc5ffbcb6b73da22da2bd2c3cbcdf7722f51aa0ee942c8d7e947e0c5c38d94db37d4b957b3d7991e7916ad203bb34ede40dadeaf4698b60514aa5a7f4a4

data/.editorconfig

@@ -0,0 +1,20 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+# Change these settings to your own preference
+indent_style = space
+indent_size = 2
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

data/.gitignore

@@ -1,18 +1,10 @@
-*.gem
-*.rbc
-.bundle
-.config
-.rvmrc
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+/.bundle/
+/.minitest-perf.db
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-gemset

@@ -0,0 +1 @@
+erlang-etf

data/.ruby-version

@@ -0,0 +1 @@
+2.4.1

data/.travis.yml

@@ -1,6 +1,17 @@
 language: ruby
+
+sudo: required
+dist: trusty
+
+env:
+  global:
+    - RUBYOPT="-W0"
+
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.1
-env: CI="travis"
+  - 2.4.1
+
+notifications:
+  email: false
+
+before_install:
+  - "gem install bundler -v 1.15.1"

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 2.0.0 (2017-06-03)
+
+* Major rewrite.
+* Fixed maps for OTP 17+.
+* Support for BERT dropped.

data/Gemfile

@@ -2,19 +2,23 @@ source 'https://rubygems.org'
 
 platforms :ruby do
   group :development do
-    gem "pry"
-    gem "pry-doc"
-    gem "redcarpet"
-    gem "yard"
+    gem 'pry'
+    gem 'pry-doc'
+    # gem 'redcarpet'
+    gem 'yard'
   end
 end
 
 group :test do
-  gem "simplecov", require: false
+  gem 'minitest-focus', require: false
+  gem 'minitest-perf', require: false
+  gem 'minitest-reporters', require: false
+  gem 'rantly', require: false
+  gem 'simplecov', require: false
   if ENV['CI']
     gem 'coveralls', require: false
   end
 end
 
-# Specify your gem's dependencies in erlang-etf.gemspec
+# Specify your gem's dependencies in jose.gemspec
 gemspec

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Andrew Bennett
+Copyright (c) 2013-2017 Andrew Bennett
 
 MIT License
 

data/README.md

@@ -1,26 +1,26 @@
-# Erlang::ETF [![Build Status](https://travis-ci.org/potatosalad/erlang-etf.png)](https://travis-ci.org/potatosalad/erlang-etf) [![Coverage Status](https://coveralls.io/repos/potatosalad/erlang-etf/badge.png)](https://coveralls.io/r/potatosalad/erlang-etf)
+# Erlang::ETF
+
+[![Travis](https://img.shields.io/travis/potatosalad/ruby-erlang-etf.svg?maxAge=86400)](https://travis-ci.org/potatosalad/ruby-erlang-etf) [![Coverage Status](https://coveralls.io/repos/github/potatosalad/ruby-erlang-etf/badge.svg?branch=master)](https://coveralls.io/github/potatosalad/ruby-erlang-etf?branch=master) [![Gem](https://img.shields.io/gem/v/erlang-etf.svg?maxAge=86400)](https://rubygems.org/gems/erlang-etf) [![Docs](https://img.shields.io/badge/yard-docs-blue.svg?maxAge=86400)](http://www.rubydoc.info/gems/erlang-etf) [![Inline docs](http://inch-ci.org/github/potatosalad/ruby-erlang-etf.svg?branch=master&style=shields)](http://inch-ci.org/github/potatosalad/ruby-erlang-etf)
 
 Erlang [External Term Format](http://erlang.org/doc/apps/erts/erl_ext_dist.html) (ETF) for Ruby.
 
+*Note:* Please see the [erlang-terms](https://github.com/potatosalad/ruby-erlang-terms) gem for more information about the Erlang-to-Ruby type mappings (for example, `Erlang::Pid`).
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'erlang-etf', require: 'erlang/etf'
+gem 'erlang-etf', '~> 2.0'
 ```
 
 And then execute:
 
-```bash
-$ bundle
-```
+    $ bundle
 
 Or install it yourself as:
 
-```bash
-$ gem install erlang-etf
-```
+    $ gem install erlang-etf
 
 ## Usage
 
@@ -47,8 +47,8 @@ Erlang.binary_to_term("\x83s\x04atom")
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Bug reports and pull requests are welcome on GitHub at https://github.com/potatosalad/ruby-erlang-etf. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,9 +1,11 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "yard"
+require "rake/testtask"
 
-YARD::Rake::YardocTask.new(:doc)
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.warning = false
+end
 
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => [:spec]
+task :default => :test

data/erlang-etf.gemspec

@@ -7,21 +7,21 @@ Gem::Specification.new do |spec|
   spec.name          = "erlang-etf"
   spec.version       = Erlang::ETF::VERSION
   spec.authors       = ["Andrew Bennett"]
-  spec.email         = ["andrew@delorum.com"]
+  spec.email         = ["andrew@pixid.com"]
+
   spec.description   = %q{Erlang External Term Format (ETF) for Ruby}
   spec.summary       = %q{Erlang External Term Format (ETF) for Ruby}
-  spec.homepage      = "https://github.com/potatosalad/erlang-etf"
+  spec.homepage      = "https://github.com/potatosalad/ruby-erlang-etf"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "binary-protocol"
-  spec.add_dependency "erlang-terms", ">= 1.1.0"
+  spec.add_dependency "erlang-terms", "~> 2.0"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "minitest"
 end

data/lib/erlang-etf.rb

@@ -0,0 +1 @@
+require 'erlang/etf'

data/lib/erlang/etf.rb

@@ -1,51 +1,384 @@
-require "binary/protocol"
-require "erlang/terms"
+require 'erlang/etf/version'
 
-require "erlang/etf/version"
-require "erlang/etf/extensions"
-require "erlang/etf/terms"
+require 'erlang/terms'
+
+require 'erlang/etf/term'
+
+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
+    # @private
+    B2T = ::Hash[*[
+      [ Erlang::ETF::Term::SMALL_INTEGER_EXT,   Erlang::ETF::SmallInteger  ],
+      [ Erlang::ETF::Term::INTEGER_EXT,         Erlang::ETF::Integer       ],
+      [ Erlang::ETF::Term::FLOAT_EXT,           Erlang::ETF::Float         ],
+      [ Erlang::ETF::Term::ATOM_EXT,            Erlang::ETF::Atom          ],
+      [ Erlang::ETF::Term::REFERENCE_EXT,       Erlang::ETF::Reference     ],
+      [ Erlang::ETF::Term::PORT_EXT,            Erlang::ETF::Port          ],
+      [ Erlang::ETF::Term::PID_EXT,             Erlang::ETF::Pid           ],
+      [ Erlang::ETF::Term::SMALL_TUPLE_EXT,     Erlang::ETF::SmallTuple    ],
+      [ Erlang::ETF::Term::LARGE_TUPLE_EXT,     Erlang::ETF::LargeTuple    ],
+      [ Erlang::ETF::Term::NIL_EXT,             Erlang::ETF::Nil           ],
+      [ Erlang::ETF::Term::STRING_EXT,          Erlang::ETF::String        ],
+      [ Erlang::ETF::Term::LIST_EXT,            Erlang::ETF::List          ],
+      [ Erlang::ETF::Term::BINARY_EXT,          Erlang::ETF::Binary        ],
+      [ Erlang::ETF::Term::SMALL_BIG_EXT,       Erlang::ETF::SmallBig      ],
+      [ Erlang::ETF::Term::LARGE_BIG_EXT,       Erlang::ETF::LargeBig      ],
+      [ Erlang::ETF::Term::NEW_REFERENCE_EXT,   Erlang::ETF::NewReference  ],
+      [ Erlang::ETF::Term::SMALL_ATOM_EXT,      Erlang::ETF::SmallAtom     ],
+      [ Erlang::ETF::Term::FUN_EXT,             Erlang::ETF::Fun           ],
+      [ Erlang::ETF::Term::NEW_FUN_EXT,         Erlang::ETF::NewFun        ],
+      [ Erlang::ETF::Term::EXPORT_EXT,          Erlang::ETF::Export        ],
+      [ Erlang::ETF::Term::BIT_BINARY_EXT,      Erlang::ETF::BitBinary     ],
+      [ Erlang::ETF::Term::NEW_FLOAT_EXT,       Erlang::ETF::NewFloat      ],
+      [ Erlang::ETF::Term::ATOM_UTF8_EXT,       Erlang::ETF::AtomUTF8      ],
+      [ Erlang::ETF::Term::SMALL_ATOM_UTF8_EXT, Erlang::ETF::SmallAtomUTF8 ],
+      [ Erlang::ETF::Term::MAP_EXT,             Erlang::ETF::Map           ],
+      # [ Erlang::ETF::Term::DIST_HEADER,             NotImplementedError  ],
+      # [ Erlang::ETF::Term::ATOM_CACHE_REF,          NotImplementedError  ],
+      # [ Erlang::ETF::Term::ATOM_INTERNAL_REF2,      NotImplementedError  ],
+      # [ Erlang::ETF::Term::ATOM_INTERNAL_REF3,      NotImplementedError  ],
+      # [ Erlang::ETF::Term::BINARY_INTERNAL_REF,     NotImplementedError  ],
+      # [ Erlang::ETF::Term::BIT_BINARY_INTERNAL_REF, NotImplementedError  ],
+      [ Erlang::ETF::Term::COMPRESSED,          Erlang::ETF::Compressed    ]
+    ].flatten].freeze
+
+    # @private
+    T2B = B2T.invert.freeze
+
+    # @private
+    TYPE = ::Hash[*[
+      [ :atom,            Erlang::ETF::Atom          ],
+      [ :atom_utf8,       Erlang::ETF::AtomUTF8      ],
+      [ :binary,          Erlang::ETF::Binary        ],
+      [ :bit_binary,      Erlang::ETF::BitBinary     ],
+      [ :export,          Erlang::ETF::Export        ],
+      [ :float,           Erlang::ETF::Float         ],
+      [ :fun,             Erlang::ETF::Fun           ],
+      [ :integer,         Erlang::ETF::Integer       ],
+      [ :large_big,       Erlang::ETF::LargeBig      ],
+      [ :large_tuple,     Erlang::ETF::LargeTuple    ],
+      [ :list,            Erlang::ETF::List          ],
+      [ :map,             Erlang::ETF::Map           ],
+      [ :new_float,       Erlang::ETF::NewFloat      ],
+      [ :new_fun,         Erlang::ETF::NewFun        ],
+      [ :new_reference,   Erlang::ETF::NewReference  ],
+      [ :nil,             Erlang::ETF::Nil           ],
+      [ :pid,             Erlang::ETF::Pid           ],
+      [ :port,            Erlang::ETF::Port          ],
+      [ :reference,       Erlang::ETF::Reference     ],
+      [ :small_atom,      Erlang::ETF::SmallAtom     ],
+      [ :small_atom_utf8, Erlang::ETF::SmallAtomUTF8 ],
+      [ :small_big,       Erlang::ETF::SmallBig      ],
+      [ :small_integer,   Erlang::ETF::SmallInteger  ],
+      [ :small_tuple,     Erlang::ETF::SmallTuple    ],
+      [ :string,          Erlang::ETF::String        ]
+    ].flatten].freeze
+
+    def self.is_atom(term)
+      return true if term.kind_of?(TYPE[:atom])
+      return true if Erlang.is_atom(term) and term.size >= 256 and term.utf8 == false
+      return false
+    end
+
+    def self.is_atom_utf8(term)
+      return true if term.kind_of?(TYPE[:atom_utf8])
+      return true if Erlang.is_atom(term) and term.size >= 256 and term.utf8 == true
+      return false
+    end
+
+    def self.is_binary(term)
+      return true if term.kind_of?(TYPE[:binary])
+      return true if Erlang.is_binary(term)
+      return false
+    end
+
+    def self.is_bit_binary(term)
+      return true if term.kind_of?(TYPE[:bit_binary])
+      return true if not Erlang.is_binary(term) and Erlang.is_bitstring(term)
+      return false
+    end
+
+    def self.is_export(term)
+      return true if term.kind_of?(TYPE[:export])
+      return true if Erlang.is_function(term) and term.kind_of?(Erlang::Export)
+      return false
+    end
+
+    def self.is_float(term)
+      return true if term.kind_of?(TYPE[:float])
+      return true if Erlang.is_float(term) and term.old == true
+      return false
+    end
+
+    def self.is_fun(term)
+      return true if term.kind_of?(TYPE[:fun])
+      return true if Erlang.is_function(term) and not is_export(term) and not term.new_function?
+      return false
+    end
+
+    def self.is_integer(term)
+      return true if term.kind_of?(TYPE[:integer])
+      return true if Erlang.is_integer(term) and not is_small_integer(term) and term >= (-(1 << 31) + 1) and term <= (+(1 << 31) - 1)
+      return false
+    end
+
+    def self.is_large_big(term)
+      return true if term.kind_of?(TYPE[:large_big])
+      return true if Erlang.is_integer(term) and not is_small_integer(term) and not is_integer(term) and not is_small_big(term)
+      return false
+    end
+
+    def self.is_large_tuple(term)
+      return true if term.kind_of?(TYPE[:large_tuple])
+      return true if Erlang.is_tuple(term) and not is_small_tuple(term)
+      return false
+    end
+
+    def self.is_list(term)
+      return true if term.kind_of?(TYPE[:list])
+      return true if Erlang.is_list(term) and not is_nil(term) and not is_string(term)
+      return false
+    end
+
+    def self.is_map(term)
+      return true if term.kind_of?(TYPE[:map])
+      return true if Erlang.is_map(term)
+      return false
+    end
+
+    def self.is_new_float(term)
+      return true if term.kind_of?(TYPE[:new_float])
+      return true if Erlang.is_float(term) and term.old == false
+      return false
+    end
+
+    def self.is_new_fun(term)
+      return true if term.kind_of?(TYPE[:new_fun])
+      return true if Erlang.is_function(term) and not is_export(term) and term.new_function?
+      return false
+    end
+
+    def self.is_new_reference(term)
+      return true if term.kind_of?(TYPE[:new_reference])
+      return true if Erlang.is_reference(term) and term.new_reference?
+      return false
+    end
 
-    extend self
+    def self.is_nil(term)
+      return true if term.kind_of?(TYPE[:nil])
+      return true if Erlang.is_list(term) and term.empty?
+      return false
+    end
+
+    def self.is_pid(term)
+      return true if term.kind_of?(TYPE[:pid])
+      return true if Erlang.is_pid(term)
+      return false
+    end
+
+    def self.is_port(term)
+      return true if term.kind_of?(TYPE[:port])
+      return true if Erlang.is_port(term)
+      return false
+    end
+
+    def self.is_reference(term)
+      return true if term.kind_of?(TYPE[:reference])
+      return true if Erlang.is_reference(term) and not term.new_reference?
+      return false
+    end
+
+    def self.is_small_atom(term)
+      return true if term.kind_of?(TYPE[:small_atom])
+      return true if Erlang.is_atom(term) and term.size < 256 and term.utf8 == false
+      return false
+    end
+
+    def self.is_small_atom_utf8(term)
+      return true if term.kind_of?(TYPE[:small_atom_utf8])
+      return true if Erlang.is_atom(term) and term.size < 256 and term.utf8 == true
+      return false
+    end
+
+    def self.is_small_big(term)
+      return true if term.kind_of?(TYPE[:small_big])
+      return true if Erlang.is_integer(term) and not is_small_integer(term) and not is_integer(term) and intlog2div8(term) < 256
+      return false
+    end
+
+    def self.is_small_integer(term)
+      return true if term.kind_of?(TYPE[:small_integer])
+      return true if Erlang.is_integer(term) and term >= 0 and term <= (+(1 << 8) - 1)
+      return false
+    end
+
+    def self.is_small_tuple(term)
+      return true if term.kind_of?(TYPE[:small_tuple])
+      return true if Erlang.is_tuple(term) and term.arity < 256
+      return false
+    end
 
-    ERLANG_MAGIC_BYTE = 131.chr.freeze
+    def self.is_string(term)
+      return true if term.kind_of?(TYPE[:string])
+      return true if Erlang.is_list(term) and not is_nil(term) and term.kind_of?(Erlang::String) and term.length < (+(1 << 16) - 1)
+      return false
+    end
 
-    def encode(term, buffer = "", options = {})
-      buffer << ERLANG_MAGIC_BYTE
-      if options[:compressed]
-        Compressed.new(term.__erlang_evolve__, options[:compressed]).serialize(buffer)
+    # @private
+    def self.intlog2(x)
+      raise ArgumentError, "x must be a positive Integer" if not x.is_a?(::Integer) or x < 1
+      r = 0
+      loop do
+        break if x == 0
+        x >>= 1
+        r += 1
+      end
+      return r
+    end
+
+    # @private
+    def self.intlog2div8(x)
+      raise ArgumentError, "x must be a non-negative Integer" if not x.is_a?(::Integer)
+      x = x.abs if x < 0
+      return 1 if x == 0
+      x = intlog2(x)
+      return 1 + ((x - 1).div(8))
+    end
+
+    # @private
+    def self.binary_to_term(buffer, etf)
+      magic = buffer.getc
+      if magic == Erlang::ETF::Term::ERLANG_MAGIC_BYTE
+        term = nil
+        begin
+          term = read_term(buffer)
+        rescue NotImplementedError => e
+          buffer.ungetc(magic)
+          raise e
+        end
+        return Erlang.from(term) if etf == false
+        return term
       else
-        term.__erlang_dump__(buffer)
+        buffer.ungetc(magic)
+        raise NotImplementedError, "unknown Erlang magic byte #{magic.inspect} (should be #{Erlang::ETF::Term::ERLANG_MAGIC_BYTE.inspect})"
       end
+      # mzbuffer.read(1)
+      # magic = buffer.read(1)
+      # if magic == Erlang::ETF::Term::ERLANG_MAGIC_BYTE
+      #   Terms.evolve(buffer)
+      # else
+      #   raise NotImplementedError, "unknown Erlang magic byte #{magic.inspect} (should be #{Erlang::ETF::Term::ERLANG_MAGIC_BYTE.inspect})"
+      # end
     end
 
-    def decode(buffer)
-      magic = buffer.read(1)
-      if magic == ERLANG_MAGIC_BYTE
-        Terms.evolve(buffer)
+    # @private
+    def self.read_term(buffer)
+      tag = buffer.getbyte
+      if B2T.key?(tag)
+        return B2T[tag].erlang_load(buffer)
       else
-        raise NotImplementedError, "unknown Erlang magic byte #{magic.inspect} (should be #{ERLANG_MAGIC_BYTE.inspect})"
+        buffer.ungetbyte(tag)
+        raise NotImplementedError, "unknown Erlang External Format tag #{tag.inspect} (see http://erlang.org/doc/apps/erts/erl_ext_dist.html)"
       end
     end
 
+    # @private
+    def self.term_to_binary(term, buffer, compressed)
+      buffer << Erlang::ETF::Term::ERLANG_MAGIC_BYTE
+      if compressed == false
+        return term.erlang_dump(buffer)
+      else
+        return Erlang::ETF::Compressed[term, level: compressed].erlang_dump(buffer)
+      end
+    end
+
+    # @private
+    def self.write_term(term, buffer)
+      term = Erlang.etf(term)
+      return term.erlang_dump(buffer)
+    end
+
   end
 
-  def self.binary_to_term(binary)
-    buffer = binary.respond_to?(:read) ? binary : StringIO.new(binary)
-    ETF.decode(buffer)
+  def self.etf(term)
+    return term.to_erlang_etf if term.respond_to?(:to_erlang_etf)
+    return term if term.kind_of?(Erlang::ETF::Term)
+    term = Erlang.from(term)
+    return term.to_erlang_etf if term.respond_to?(:to_erlang_etf)
+    type = external_type(term)
+    constructor = Erlang::ETF::TYPE[type]
+    raise NotImplementedError, "unsupported type #{type.inspect}" if constructor.nil?
+    return term if term.kind_of?(constructor)
+    return constructor[term]
   end
 
-  def self.term_to_binary(term, buffer_or_options = "", options = nil)
-    if buffer_or_options.kind_of?(::Hash)
-      buffer = options || ""
-      options = buffer_or_options
-    else
-      buffer = buffer_or_options
-    end
-    options ||= {}
-    ETF.encode(term, buffer, options)
+  def self.external_type(term)
+    return term.erlang_external_type if term.respond_to?(:erlang_external_type)
+    term = Erlang.from(term)
+    return :atom            if Erlang::ETF.is_atom(term)
+    return :atom_utf8       if Erlang::ETF.is_atom_utf8(term)
+    return :binary          if Erlang::ETF.is_binary(term)
+    return :bit_binary      if Erlang::ETF.is_bit_binary(term)
+    return :export          if Erlang::ETF.is_export(term)
+    return :float           if Erlang::ETF.is_float(term)
+    return :fun             if Erlang::ETF.is_fun(term)
+    return :integer         if Erlang::ETF.is_integer(term)
+    return :large_big       if Erlang::ETF.is_large_big(term)
+    return :large_tuple     if Erlang::ETF.is_large_tuple(term)
+    return :list            if Erlang::ETF.is_list(term)
+    return :map             if Erlang::ETF.is_map(term)
+    return :new_float       if Erlang::ETF.is_new_float(term)
+    return :new_fun         if Erlang::ETF.is_new_fun(term)
+    return :new_reference   if Erlang::ETF.is_new_reference(term)
+    return :nil             if Erlang::ETF.is_nil(term)
+    return :pid             if Erlang::ETF.is_pid(term)
+    return :port            if Erlang::ETF.is_port(term)
+    return :reference       if Erlang::ETF.is_reference(term)
+    return :small_atom      if Erlang::ETF.is_small_atom(term)
+    return :small_atom_utf8 if Erlang::ETF.is_small_atom_utf8(term)
+    return :small_big       if Erlang::ETF.is_small_big(term)
+    return :small_integer   if Erlang::ETF.is_small_integer(term)
+    return :small_tuple     if Erlang::ETF.is_small_tuple(term)
+    return :string          if Erlang::ETF.is_string(term)
+    raise NotImplementedError
+  end
+
+  def self.binary_to_term(buffer, etf: false)
+    buffer = ::StringIO.new(Erlang::ETF::Term.binary_encoding(buffer)) if buffer.respond_to?(:force_encoding)
+    return Erlang::ETF.binary_to_term(buffer, etf)
+  end
+
+  def self.term_to_binary(term, buffer: ::String.new, compressed: false)
+    term = Erlang.etf(term)
+    buffer = Erlang::ETF::Term.binary_encoding(buffer)
+    return Erlang::ETF.term_to_binary(term, buffer, compressed)
   end
 
-end
+end