erlang-etf 1.0.0

data/spec/erlang/etf/export_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Export do
+  let(:term_class) { Erlang::ETF::Export }
+
+  let(:mod)      { Erlang::ETF::Atom.new("erlang").tap(&:serialize) }
+  let(:function) { Erlang::ETF::Atom.new("now").tap(&:serialize) }
+  let(:arity)    { Erlang::ETF::SmallInteger.new(0).tap(&:serialize) }
+
+  describe '[class]' do
+    describe 'deserialize' do
+      let(:buffer) { StringIO.new(bytes.pack('C*')) }
+      subject { term_class.deserialize(buffer) }
+
+      let(:bytes) { [100, 0, 6, 101, 114, 108, 97, 110, 103, 100, 0, 3, 110, 111, 119, 97, 0] }
+
+      its(:mod)      { should eq(mod) }
+      its(:function) { should eq(function) }
+      its(:arity)    { should eq(arity) }
+    end
+
+    describe 'new' do
+      subject { term_class.new(mod, function, arity) }
+
+      its(:mod)      { should eq(mod) }
+      its(:function) { should eq(function) }
+      its(:arity)    { should eq(arity) }
+    end
+  end
+
+  describe '[instance]' do
+    let(:term) { term_class.new(mod, function, arity) }
+
+    describe 'serialize' do
+      subject { term.serialize }
+
+      let(:bytes) { [113, 100, 0, 6, 101, 114, 108, 97, 110, 103, 100, 0, 3, 110, 111, 119, 97, 0].pack('C*') }
+
+      it { should eq(bytes) }
+    end
+
+    describe '__erlang_type__' do
+      subject { term.__erlang_type__ }
+
+      it { should eq(:export) }
+    end
+
+    describe '__ruby_evolve__' do
+      let(:ruby_obj) { ::Erlang::Export.new(:erlang, :now, 0) }
+      subject { term.__ruby_evolve__ }
+
+      it { should eq(ruby_obj) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/array_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::Array do
+  let(:klass) { ::Array }
+
+  describe '[instance]' do
+    let(:instance) { klass.new(*args) }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      context 'when empty' do
+        let(:args) {[ ]}
+        it { should eq(:nil) }
+      end
+
+      context 'when not empty' do
+        let(:args) {[ [:a] ]}
+        it { should eq(:list) }
+      end
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      context 'when empty' do
+        let(:args) {[ ]}
+        it { should eq(Erlang::ETF::Nil.new) }
+      end
+
+      context 'when not empty' do
+        let(:args) {[ [:a] ]}
+        it { should eq(Erlang::ETF::List.new([Erlang::ETF::SmallAtom.new("a")])) }
+      end
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/big_decimal_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::BigDecimal do
+  let(:klass) { ::BigDecimal }
+
+  describe '[instance]' do
+    let(:instance) { klass.new(*args) }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      let(:args) {[ "1.1" ]}
+      it { should eq(:float) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      let(:args) {[ "1.1" ]}
+      it { should eq(Erlang::ETF::Float.new(instance)) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/erlang-export_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::ErlangExport do
+  let(:klass) { ::Erlang::Export }
+
+  describe '[instance]' do
+    let(:instance) { klass.new(*args) }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      let(:args) {[ :erlang, :now, 0 ]}
+      it { should eq(:export) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      let(:args) {[ :erlang, :now, 0 ]}
+      it { should eq(
+        Erlang::ETF::Export.new(
+          Erlang::ETF::SmallAtom.new("erlang"),
+          Erlang::ETF::SmallAtom.new("now"),
+          Erlang::ETF::SmallInteger.new(0)
+        )
+      ) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/erlang-list_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::ErlangList do
+  let(:klass) { ::Erlang::List }
+
+  describe '[instance]' do
+    let(:instance) { klass[*elements].tail(tail) }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      context 'when empty and proper' do
+        let(:elements) { [] }
+        let(:tail)     { [] }
+
+        it { should eq(:nil) }
+      end
+
+      context 'when empty and improper' do
+        let(:elements) { [] }
+        let(:tail)     { :a }
+
+        it { should eq(:list) }
+      end
+
+      context 'when not empty and proper' do
+        let(:elements) { [:a] }
+        let(:tail)     { [] }
+
+        it { should eq(:list) }
+      end
+
+      context 'when not empty and improper' do
+        let(:elements) { [:a] }
+        let(:tail)     { :a }
+
+        it { should eq(:list) }
+      end
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      context 'when empty and proper' do
+        let(:elements) { [] }
+        let(:tail)     { [] }
+
+        it { should eq(Erlang::ETF::Nil.new) }
+      end
+
+      context 'when empty and improper' do
+        let(:elements) { [] }
+        let(:tail)     { :a }
+
+        it { should eq(Erlang::ETF::List.new([], Erlang::ETF::SmallAtom.new("a"))) }
+      end
+
+      context 'when not empty and proper' do
+        let(:elements) { [:a] }
+        let(:tail)     { [] }
+
+        it { should eq(Erlang::ETF::List.new([Erlang::ETF::SmallAtom.new("a")])) }
+      end
+
+      context 'when not empty and improper' do
+        let(:elements) { [:a] }
+        let(:tail)     { :a }
+
+        it { should eq(Erlang::ETF::List.new([Erlang::ETF::SmallAtom.new("a")], Erlang::ETF::SmallAtom.new("a"))) }
+      end
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/erlang-nil_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::ErlangNil do
+  let(:klass) { ::Erlang::Nil }
+
+  describe '[instance]' do
+    let(:instance) { klass.new }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      it { should eq(:nil) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      it { should eq(Erlang::ETF::Nil.new) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/erlang-pid_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::ErlangPid do
+  let(:klass) { ::Erlang::Pid }
+
+  describe '[instance]' do
+    let(:instance) { klass.new(*args) }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      let(:args) {[ :'nonode@nohost', 100, 10, 1 ]}
+      it { should eq(:pid) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      let(:args) {[ :'nonode@nohost', 100, 10, 1 ]}
+      it { should eq(
+        Erlang::ETF::Pid.new(
+          Erlang::ETF::SmallAtom.new("nonode@nohost"),
+          100,
+          10,
+          1
+        )
+      ) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/erlang-string_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::ErlangString do
+  let(:klass) { ::Erlang::String }
+
+  describe '[instance]' do
+    let(:instance) { klass.new(*args) }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      let(:args) {[ "test" ]}
+      it { should eq(:string) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      let(:args) {[ "test" ]}
+      it { should eq(Erlang::ETF::String.new("test")) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/erlang-tuple_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::ErlangTuple do
+  let(:klass) { ::Erlang::Tuple }
+
+  describe '[instance]' do
+    let(:instance) { klass[*elements] }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      context 'when empty' do
+        let(:elements) { [] }
+
+        it { should eq(:small_tuple) }
+      end
+
+      context 'when arity is less than 256' do
+        let(:elements) { [:a] }
+
+        it { should eq(:small_tuple) }
+      end
+
+      context 'when arity is greater than or equal to 256' do
+        let(:elements) { [[]] * 256 }
+
+        it { should eq(:large_tuple) }
+      end
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      context 'when empty' do
+        let(:elements) { [] }
+
+        it { should eq(Erlang::ETF::SmallTuple.new([])) }
+      end
+
+      context 'when arity is less than 256' do
+        let(:elements) { [:a] }
+
+        it { should eq(Erlang::ETF::SmallTuple.new([Erlang::ETF::SmallAtom.new("a")])) }
+      end
+
+      context 'when arity is greater than or equal to 256' do
+        let(:elements) { [[]] * 256 }
+
+        it { should eq(Erlang::ETF::LargeTuple.new([Erlang::ETF::Nil.new] * 256)) }
+      end
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/false_class_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::FalseClass do
+  let(:klass) { ::FalseClass }
+
+  describe '[instance]' do
+    let(:instance) { false }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      it { should eq(:bert_boolean) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      it { should eq(
+        Erlang::ETF::SmallTuple.new([
+          Erlang::ETF::SmallAtom.new("bert"),
+          Erlang::ETF::SmallAtom.new("false")
+        ])
+      ) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/float_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::Float do
+  let(:klass) { ::Float }
+
+  describe '[instance]' do
+    let(:instance) { 1.1 }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      it { should eq(:new_float) }
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      it { should eq(Erlang::ETF::NewFloat.new(instance)) }
+    end
+  end
+
+end

data/spec/erlang/etf/extensions/hash_spec.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Erlang::ETF::Extensions::Hash do
+  let(:klass) { ::Hash }
+
+  describe '[instance]' do
+    let(:instance) { klass[*keyvalues] }
+
+    describe '__erlang_type__' do
+      subject { instance.__erlang_type__ }
+
+      context 'when empty' do
+        let(:keyvalues) { [] }
+
+        it { should eq(:bert_dict) }
+      end
+
+      context 'when arity is less than 256' do
+        let(:keyvalues) { [:a, 1] }
+
+        it { should eq(:bert_dict) }
+      end
+
+      context 'when arity is greater than or equal to 256' do
+        let(:keyvalues) { (1..256).zip([Erlang::Nil.new] * 256).flatten }
+
+        it { should eq(:bert_dict) }
+      end
+    end
+
+    describe '__erlang_evolve__' do
+      subject { instance.__erlang_evolve__ }
+
+      context 'when empty' do
+        let(:keyvalues) { [] }
+
+        it { should eq(
+          Erlang::ETF::SmallTuple.new([
+            Erlang::ETF::SmallAtom.new("bert"),
+            Erlang::ETF::SmallAtom.new("dict"),
+            Erlang::ETF::Nil.new
+          ])
+        ) }
+      end
+
+      context 'when arity is less than 256' do
+        let(:keyvalues) { [:a, 1] }
+
+        it { should eq(
+          Erlang::ETF::SmallTuple.new([
+            Erlang::ETF::SmallAtom.new("bert"),
+            Erlang::ETF::SmallAtom.new("dict"),
+            Erlang::ETF::List.new([
+              Erlang::ETF::SmallTuple.new([
+                Erlang::ETF::SmallAtom.new("a"),
+                Erlang::ETF::SmallInteger.new(1)
+              ])
+            ])
+          ])
+        ) }
+      end
+
+      context 'when arity is greater than or equal to 256' do
+        let(:keyvalues) { (1..256).zip([Erlang::Nil.new] * 256).flatten }
+
+        let(:elements) {
+          elements = []
+          1.upto(256) do |i|
+            elements << Erlang::ETF::SmallTuple.new([
+              i.__erlang_evolve__,
+              Erlang::ETF::Nil.new
+            ])
+          end
+          elements
+        }
+
+        it { should eq(
+          Erlang::ETF::SmallTuple.new([
+            Erlang::ETF::SmallAtom.new("bert"),
+            Erlang::ETF::SmallAtom.new("dict"),
+            Erlang::ETF::List.new(elements)
+          ])
+        ) }
+      end
+    end
+  end
+
+end