erlang-etf 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 195a05d3181de002ad6dff10e6994d94f722e8b2
+  data.tar.gz: 18a71520747f118760e31724f9dc135ebdc38dde
+SHA512:
+  metadata.gz: c97cd0e64ceaf45946b042117c7cab7cb4654dcb325df611e4f35fdc323970b13b42317901d074ae1daaafff8901959332446e4737e53d37cdd5d874fafe0c5f
+  data.tar.gz: 2723c6b9376a9e1b235a5e195f30329f777f53b0c841f19bd4ebb44d975d2190d91b6fe2ab61be68711819c8fc5b8fbfe8c1ad83ad703d17fb000b1635d10972

data/.gitignore

@@ -0,0 +1,18 @@
+*.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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in erlang-etf.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrew Bennett
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# Erlang::Etf
+
+[![Build Status](https://travis-ci.org/potatosalad/erlang-etf.png)](https://travis-ci.org/potatosalad/erlang-etf)
+
+Erlang [External Term Format](http://erlang.org/doc/apps/erts/erl_ext_dist.html) (ETF) for Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'erlang-etf', require: 'erlang/etf'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install erlang-etf
+```
+
+## Usage
+
+### Erlang.term_to_binary(term)
+
+```ruby
+Erlang.term_to_binary(:atom)
+# => "\x83s\x04atom"
+```
+
+### Erlang.binary_to_term(binary)
+
+```ruby
+Erlang.binary_to_term("\x83s\x04atom")
+# => :atom
+```
+
+## 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

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec]

data/erlang-etf.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'erlang/etf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "erlang-etf"
+  spec.version       = Erlang::ETF::VERSION
+  spec.authors       = ["Andrew Bennett"]
+  spec.email         = ["andrew@delorum.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.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.require_paths = ["lib"]
+
+  spec.add_dependency "binary-protocol"
+  spec.add_dependency "erlang-terms"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-doc"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+end

data/lib/erlang/etf.rb

@@ -0,0 +1,40 @@
+require "binary/protocol"
+require "erlang/terms"
+
+require "erlang/etf/version"
+require "erlang/etf/extensions"
+require "erlang/etf/terms"
+
+module Erlang
+  module ETF
+
+    extend self
+
+    ERLANG_MAGIC_BYTE = 131.chr.freeze
+
+    def encode(term, buffer = "")
+      buffer << ERLANG_MAGIC_BYTE
+      term.__erlang_dump__(buffer)
+    end
+
+    def decode(buffer)
+      magic = buffer.read(1)
+      if magic == ERLANG_MAGIC_BYTE
+        Terms.evolve(buffer)
+      else
+        raise NotImplementedError, "unknown Erlang magic byte #{magic.inspect} (should be #{ERLANG_MAGIC_BYTE.inspect})"
+      end
+    end
+
+  end
+
+  def self.binary_to_term(binary)
+    buffer = binary.respond_to?(:read) ? binary : StringIO.new(binary)
+    ETF.decode(buffer)
+  end
+
+  def self.term_to_binary(term, buffer = "")
+    ETF.encode(term, buffer)
+  end
+
+end

data/lib/erlang/etf/atom.rb

@@ -0,0 +1,46 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 2   | Len
+    # --- | --- | --------
+    # 100 | Len | AtomName
+    #
+    # An atom is stored with a 2 byte unsigned length in big-endian
+    # order, followed by Len numbers of 8 bit Latin1 characters that
+    # forms the AtomName.
+    #
+    # Note: The maximum allowed value for Len is 255.
+    #
+    class Atom
+      include Term
+
+      uint8 :tag, always: Terms::ATOM_EXT
+
+      uint16be :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/atom_utf8.rb

@@ -0,0 +1,44 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 2   | Len
+    # --- | --- | --------
+    # 118 | Len | AtomName
+    #
+    # An atom is stored with a 2 byte unsigned length in big-endian
+    # order, followed by Len bytes containing the AtomName encoded in
+    # UTF-8.
+    #
+    class AtomUTF8
+      include Term
+
+      uint8 :tag, always: Terms::ATOM_UTF8_EXT
+
+      uint16be :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/bert.rb

@@ -0,0 +1,74 @@
+module Erlang
+  module ETF
+    module BERT
+      extend self
+
+      def evolve(tuple)
+        if tuple.elements[1].respond_to?(:atom_name)
+          case tuple.elements[1].atom_name.to_s.intern
+          ## boolean ##
+          when :false
+            false
+          when :true
+            true
+
+          ## dict ##
+          when :dict
+            if tuple.elements[2].respond_to?(:__ruby_evolve__) and
+              ((list = tuple.elements[2].__ruby_evolve__).is_a?(::Erlang::List) or (list.respond_to?(:empty?) and list.empty?))
+              list.inject({}) do |hash, (key, value)|
+                hash[key] = value
+                hash
+              end
+            else
+              unknown(tuple)
+            end
+
+          ## nil ##
+          when :nil
+            nil
+
+          ## regex ##
+          when :regex
+            if tuple.elements[2].is_a?(Erlang::ETF::Binary) and
+              (tuple.elements[3].is_a?(Erlang::ETF::List) or tuple.elements[3].is_a?(Erlang::ETF::Nil))
+              
+              source = tuple.elements[2].__ruby_evolve__
+              opts   = tuple.elements[3].__ruby_evolve__
+
+              options = 0
+              options |= ::Regexp::EXTENDED   if opts.include?(:extended)
+              options |= ::Regexp::IGNORECASE if opts.include?(:caseless)
+              options |= ::Regexp::MULTILINE  if opts.include?(:multiline)
+              ::Regexp.new(source, options)
+            else
+              unknown(tuple)
+            end
+
+          ## time ##
+          when :time
+            if tuple.arity == 5
+              megaseconds  = tuple.elements[2].__ruby_evolve__
+              seconds      = tuple.elements[3].__ruby_evolve__
+              microseconds = tuple.elements[4].__ruby_evolve__
+
+              Time.at(megaseconds * 1_000_000 + seconds, microseconds)
+            else
+              unknown(tuple)
+            end
+
+          else
+            unknown(tuple)
+          end
+        else
+          unknown(tuple)
+        end
+      end
+
+      def unknown(tuple)
+        ::Erlang::Tuple[*tuple.elements.map(&:__ruby_evolve__)]
+      end
+
+    end
+  end
+end

data/lib/erlang/etf/binary.rb

@@ -0,0 +1,44 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 4   | Len
+    # --- | --- | ----
+    # 109 | Len | Data
+    #
+    # Binaries are generated with bit syntax expression or with
+    # list_to_binary/1, term_to_binary/1, or as input from binary
+    # ports.
+    # The Len length field is an unsigned 4 byte integer (big endian).
+    #
+    class Binary
+      include Term
+
+      uint8 :tag, always: Terms::BINARY_EXT
+
+      uint32be :len, default: 0 do
+        string :data
+      end
+
+      undef deserialize_data
+      def deserialize_data(buffer)
+        self.data = buffer.read(len).from_utf8_binary
+      end
+
+      undef serialize_data
+      def serialize_data(buffer)
+        buffer << data.to_utf8_binary
+      end
+
+      finalize
+
+      def initialize(data)
+        @data = data
+      end
+
+      def __ruby_evolve__
+        data
+      end
+    end
+  end
+end

data/lib/erlang/etf/bit_binary.rb

@@ -0,0 +1,47 @@
+module Erlang
+  module ETF
+
+    #
+    # 1  | 4   | 1    | Len
+    # -- | --- | ---- | ----
+    # 77 | Len | Bits | Data
+    #
+    # This term represents a bitstring whose length in bits is not a
+    # multiple of 8 (created using the bit syntax in R12B and later).
+    # The Len field is an unsigned 4 byte integer (big endian).
+    # The Bits field is the number of bits that are used in the last
+    # byte in the data field, counting from the most significant bit
+    # towards the least significant.
+    #
+    class BitBinary
+      include Term
+
+      uint8 :tag, always: Terms::BIT_BINARY_EXT
+
+      uint32be :len, always: -> { data.bytesize }
+
+      uint8 :bits
+
+      string :data, default: ""
+
+      undef serialize_data
+      def serialize_data(buffer)
+        buffer << data.to_utf8_binary
+      end
+
+      deserialize do |buffer|
+        len, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
+        deserialize_bits(buffer)
+        self.data = buffer.read(len).from_utf8_binary
+        self
+      end
+
+      finalize
+
+      def initialize(bits, data = "")
+        self.bits = bits
+        self.data = data
+      end
+    end
+  end
+end