erlang-terms 1.1.0 → 2.0.1

data/lib/erlang/nil.rb

@@ -1,15 +1,78 @@
+require 'singleton'
+
 module Erlang
-  class Nil
-    def inspect
-      "#<#{self.class.name} []>"
+  # A list without any elements. This is a singleton, since all empty lists are equivalent.
+  #
+  # Licensing
+  # =========
+  #
+  # Portions taken and modified from https://github.com/hamstergem/hamster
+  #
+  #     Copyright (c) 2009-2014 Simon Harris
+  #
+  #     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.
+  #
+  # @private
+  class EmptyList
+    include Singleton
+    include Erlang::Term
+    include Erlang::List
+    include Erlang::Immutable
+
+    # @private
+    def hash
+      return Erlang::EmptyList.hash
+    end
+
+    # There is no first item in an empty list, so return `Undefined`.
+    # @return [Undefined]
+    def head
+      return Erlang::Undefined
+    end
+    alias :first :head
+
+    # There are no subsequent elements, so return an empty list.
+    # @return [self]
+    def tail
+      return self
     end
 
-    def ==(other)
-      if other == []
-        true
-      else
-        other === self.class
-      end
+    def empty?
+      return true
     end
+
+    def improper?
+      return false
+    end
+
+    # Return the number of items in this `List`.
+    # @return [Integer]
+    def size
+      return 0
+    end
+    alias :length :size
   end
-end
+
+  # A list without any elements. This is a singleton, since all empty lists are equivalent.
+  Nil = EmptyList.instance
+
+  # @private
+  EmptyList.freeze
+end

data/lib/erlang/pid.rb

@@ -1,31 +1,133 @@
 module Erlang
+  # A `Pid` is a process identifier object obtained from [`erlang:spawn/3`](http://erlang.org/doc/man/erlang.html#spawn-3).
+  #
+  # ### Creating Pids
+  #
+  #     Erlang::Pid["nonode@nohost", 38, 0, 0]
+  #     # => Erlang::Pid[:"nonode@nohost", 38, 0, 0]
+  #
   class Pid
-    attr_accessor :node, :id, :serial, :creation
+    include Erlang::Term
+    include Erlang::Immutable
 
+    # Return the node for this `Pid`
+    # @return [Atom]
+    attr_reader :node
+
+    # Return the id for this `Pid`
+    # @return [Integer]
+    attr_reader :id
+
+    # Return the serial for this `Pid`
+    # @return [Integer]
+    attr_reader :serial
+
+    # Return the creation for this `Pid`
+    # @return [Integer]
+    attr_reader :creation
+
+    class << self
+      # Create a new `Pid` populated with the given `node`, `id`, `serial`, and `creation`.
+      # @param node [Atom, Symbol] The node atom
+      # @param id [Integer] The id as a non-negative integer
+      # @param serial [Integer] The serial time as a non-negative integer
+      # @param creation [Integer] The creation time as a non-negative integer
+      # @return [Pid]
+      # @raise [ArgumentError] if `node` is not an `Atom` or one of `id`, `serial`, or `creation` are not non-negative `Integer`s
+      def [](node, id, serial = 0, creation = 0)
+        return new(node, id, serial, creation)
+      end
+
+      # Compares `a` and `b` and returns whether they are less than,
+      # equal to, or greater than each other.
+      #
+      # @param a [Pid] The left argument
+      # @param b [Pid] The right argument
+      # @return [-1, 0, 1]
+      # @raise [ArgumentError] if `a` or `b` is not a `Pid`
+      def compare(a, b)
+        raise ArgumentError, "'a' must be of Erlang::Pid type" unless a.kind_of?(Erlang::Pid)
+        raise ArgumentError, "'b' must be of Erlang::Pid type" unless b.kind_of?(Erlang::Pid)
+        c = Erlang.compare(a.node, b.node)
+        return c if c != 0
+        c = Erlang.compare(a.id, b.id)
+        return c if c != 0
+        c = Erlang.compare(a.serial, b.serial)
+        return c if c != 0
+        c = Erlang.compare(a.creation, b.creation)
+        return c
+      end
+    end
+
+    # @private
     def initialize(node, id, serial = 0, creation = 0)
-      self.node     = node
-      self.id       = id
-      self.serial   = serial
-      self.creation = creation
+      raise ArgumentError, 'id must be a non-negative Integer' if not id.is_a?(::Integer) or id < 0
+      raise ArgumentError, 'serial must be a non-negative Integer' if not serial.is_a?(::Integer) or serial < 0
+      raise ArgumentError, 'creation must be a non-negative Integer' if not creation.is_a?(::Integer) or creation < 0
+      @node = Erlang::Atom[node]
+      @id = id.freeze
+      @serial = serial.freeze
+      @creation = creation.freeze
+    end
+
+    # @private
+    def hash
+      state = [@node, @id, @serial, @creation]
+      return state.reduce(Erlang::Pid.hash) { |acc, item| (acc << 5) - acc + item.hash }
+    end
+
+    # Return true if `other` has the same type and contents as this `Pid`.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean]
+    def eql?(other)
+      return true if other.equal?(self)
+      if instance_of?(other.class)
+        return !!(node == other.node &&
+          id == other.id &&
+          serial == other.serial &&
+          creation == other.creation)
+      else
+        return !!(Erlang.compare(other, self) == 0)
+      end
+    end
+    alias :== :eql?
+
+    # Return the contents of this `Pid` as a Erlang-readable `::String`.
+    #
+    # @example
+    #     Erlang::Pid["nonode@nohost", 38, 0, 0].erlang_inspect
+    #     # => "{'pid','nonode@nohost',38,0,0}"
+    #
+    # @return [::String]
+    def erlang_inspect(raw = false)
+      if raw == true and Erlang.respond_to?(:term_to_binary)
+        result = 'erlang:binary_to_term('
+        result << Erlang.inspect(Erlang.term_to_binary(self), raw: raw)
+        result << ')'
+        return result
+      else
+        return Erlang.inspect(Erlang::Tuple[:pid, node, id, serial, creation], raw: raw)
+      end
     end
 
-    # @return [String] the nicely formatted version of the message
+    # @return [::String] the nicely formatted version of the `Pid`.
     def inspect
-      "#<#{self.class.name} <0.#{id}.#{serial}> @node=#{node.inspect} @creation=#{creation.inspect}>"
+      return "Erlang::Pid[#{node.inspect}, #{id.inspect}, #{serial.inspect}, #{creation.inspect}]"
     end
 
-    def pretty_inspect
-      "#<#{self.class.name} <0.#{id}.#{serial}>\n" <<
-      "  @node=#{node.inspect}\n" <<
-      "  @creation=#{creation.inspect}>"
+    # @return [::Array]
+    # @private
+    def marshal_dump
+      return [@node, @id, @serial, @creation]
     end
 
-    def ==(other)
-      self.class === other &&
-      node.to_s == other.node.to_s &&
-      id.to_s   == other.id.to_s &&
-      serial    == other.serial &&
-      creation  == other.creation
+    # @private
+    def marshal_load(args)
+      node, id, serial, creation = args
+      initialize(node, id, serial, creation)
+      __send__(:immutable!)
+      return self
     end
   end
-end
+end

data/lib/erlang/port.rb

@@ -0,0 +1,123 @@
+module Erlang
+  # A `Port` is a port object obtained from [`erlang:open_port/2`](http://erlang.org/doc/man/erlang.html#open_port-2).
+  #
+  # ### Creating Ports
+  #
+  #     Erlang::Port["nonode@nohost", 100, 1]
+  #     # => Erlang::Port[:"nonode@nohost", 100, 1]
+  #
+  class Port
+    include Erlang::Term
+    include Erlang::Immutable
+
+    # Return the node for this `Port`
+    # @return [Atom]
+    attr_reader :node
+
+    # Return the id for this `Port`
+    # @return [Integer]
+    attr_reader :id
+
+    # Return the creation for this `Port`
+    # @return [Integer]
+    attr_reader :creation
+
+    class << self
+      # Create a new `Port` populated with the given `node`, `id`, and `creation`.
+      # @param node [Atom, Symbol] The node atom
+      # @param id [Integer] The id as a non-negative integer
+      # @param creation [Integer] The creation time as a non-negative integer
+      # @return [Port]
+      # @raise [ArgumentError] if `node` is not an `Atom` or `id` or `creation` are not non-negative `Integer`s
+      def [](node, id, creation = 0)
+        return new(node, id, creation)
+      end
+
+      # Compares `a` and `b` and returns whether they are less than,
+      # equal to, or greater than each other.
+      #
+      # @param a [Port] The left argument
+      # @param b [Port] The right argument
+      # @return [-1, 0, 1]
+      # @raise [ArgumentError] if `a` or `b` is not a `Port`
+      def compare(a, b)
+        raise ArgumentError, "'a' must be of Erlang::Port type" unless a.kind_of?(Erlang::Port)
+        raise ArgumentError, "'b' must be of Erlang::Port type" unless b.kind_of?(Erlang::Port)
+        c = Erlang.compare(a.node, b.node)
+        return c if c != 0
+        c = Erlang.compare(a.id, b.id)
+        return c if c != 0
+        c = Erlang.compare(a.creation, b.creation)
+        return c
+      end
+    end
+
+    # @private
+    def initialize(node, id, creation = 0)
+      raise ArgumentError, 'id must be a non-negative Integer' if not id.is_a?(::Integer) or id < 0
+      raise ArgumentError, 'creation must be a non-negative Integer' if not creation.is_a?(::Integer) or creation < 0
+      @node = Erlang::Atom[node]
+      @id = id.freeze
+      @creation = creation.freeze
+    end
+
+    # @private
+    def hash
+      state = [@node, @id, @creation]
+      return state.reduce(Erlang::Port.hash) { |acc, item| (acc << 5) - acc + item.hash }
+    end
+
+    # Return true if `other` has the same type and contents as this `Port`.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean]
+    def eql?(other)
+      return true if other.equal?(self)
+      if instance_of?(other.class)
+        return !!(node == other.node &&
+          id == other.id &&
+          creation == other.creation)
+      else
+        return !!(Erlang.compare(other, self) == 0)
+      end
+    end
+    alias :== :eql?
+
+    # Return the contents of this `Port` as a Erlang-readable `::String`.
+    #
+    # @example
+    #     Erlang::Port["nonode@nohost", 100, 1].erlang_inspect
+    #     # => "{'port','nonode@nohost',100,1}"
+    #
+    # @return [::String]
+    def erlang_inspect(raw = false)
+      if raw == true and Erlang.respond_to?(:term_to_binary)
+        result = 'erlang:binary_to_term('
+        result << Erlang.inspect(Erlang.term_to_binary(self), raw: raw)
+        result << ')'
+        return result
+      else
+        return Erlang.inspect(Erlang::Tuple[:port, node, id, creation], raw: raw)
+      end
+    end
+
+    # @return [::String] the nicely formatted version of the `Port`.
+    def inspect
+      return "Erlang::Port[#{node.inspect}, #{id.inspect}, #{creation.inspect}]"
+    end
+
+    # @return [::Array]
+    # @private
+    def marshal_dump
+      return [@node, @id, @creation]
+    end
+
+    # @private
+    def marshal_load(args)
+      node, id, creation = args
+      initialize(node, id, creation)
+      __send__(:immutable!)
+      return self
+    end
+  end
+end

data/lib/erlang/reference.rb

@@ -0,0 +1,161 @@
+module Erlang
+  # @private
+  class NewReferenceError < Erlang::Error; end
+
+  # A `Reference` is an [unique reference](http://erlang.org/doc/efficiency_guide/advanced.html#unique_references).
+  #
+  # ### Creating New References
+  #
+  #     # New reference
+  #     Erlang::Reference["nonode@nohost", 0, [0, 0, 0]]
+  #     # => Erlang::Reference[:"nonode@nohost", 0, [0, 0, 0]]
+  #     # Old reference
+  #     Erlang::Reference["nonode@nohost", 0, 0]
+  #     # => Erlang::Reference[:"nonode@nohost", 0, 0]
+  #
+  class Reference
+    include Erlang::Term
+    include Erlang::Immutable
+
+    # Return the node for this `Reference`
+    # @return [Atom]
+    attr_reader :node
+
+    # Return the creation for this `Reference`
+    # @return [Integer]
+    attr_reader :creation
+
+    # Return the ids for this `Reference`
+    # @return [[Integer]]
+    attr_reader :ids
+
+    class << self
+      # Create a new `Reference` populated with the given node, creation, and id(s).
+      # @param node [Atom, Symbol] The node atom
+      # @param creation [Integer] The creation time as a non-negative integer
+      # @param ids [Integer] The ids as a `List` of non-negative integers
+      # @return [Reference]
+      # @raise [ArgumentError] if `node` is not an `Atom` or `creation` or `ids` are not non-negative `Integer`s
+      def [](node, creation, ids)
+        return new(node, creation, ids)
+      end
+
+      # Compares `a` and `b` and returns whether they are less than,
+      # equal to, or greater than each other.
+      #
+      # @param a [Reference] The left argument
+      # @param b [Reference] The right argument
+      # @return [-1, 0, 1]
+      # @raise [ArgumentError] if `a` or `b` is not a `Reference`
+      def compare(a, b)
+        raise ArgumentError, "'a' must be of Erlang::Reference type" unless a.kind_of?(Erlang::Reference)
+        raise ArgumentError, "'b' must be of Erlang::Reference type" unless b.kind_of?(Erlang::Reference)
+        c = Erlang.compare(a.node, b.node)
+        return c if c != 0
+        c = Erlang.compare(a.creation, b.creation)
+        return c if c != 0
+        c = Erlang.compare(a.ids, b.ids)
+        return c
+      end
+    end
+
+    # @private
+    def initialize(node, creation, ids)
+      raise ArgumentError, 'creation must be a non-negative Integer' if not creation.is_a?(::Integer) or creation < 0
+      ids = Erlang.from(ids)
+      if Erlang.is_list(ids)
+        raise ArgumentError, 'ids list cannot be empty' if ids.empty?
+        raise ArgumentError, 'ids must be a List of non-negative Integer' if ids.any? { |id| !id.is_a?(::Integer) or id < 0 }
+        @node = Erlang::Atom[node]
+        @creation = creation.freeze
+        @ids = ids
+      else
+        id = ids
+        raise ArgumentError, 'id must be a non-negative Integer' if not id.is_a?(::Integer) or id < 0
+        @node = Erlang::Atom[node]
+        @creation = creation.freeze
+        @ids = id.freeze
+      end
+    end
+
+    # @private
+    def hash
+      state = [@node, @creation, @ids]
+      return state.reduce(Erlang::Reference.hash) { |acc, item| (acc << 5) - acc + item.hash }
+    end
+
+    # Return true if `other` has the same type and contents as this `Reference`.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean]
+    def eql?(other)
+      return true if other.equal?(self)
+      if instance_of?(other.class)
+        return !!(@node == other.node &&
+          @creation == other.creation &&
+          @ids == other.ids)
+      else
+        return !!(Erlang.compare(other, self) == 0)
+      end
+    end
+    alias :== :eql?
+
+    # Return the singular id if this `Reference` is an old
+    # reference.  Otherwise, raise a `NewReferenceError`.
+    #
+    # @return [Integer]
+    # @raise [NewReferenceError] if new reference
+    def id
+      raise Erlang::NewReferenceError if new_reference?
+      return @ids
+    end
+
+    # Return true if this is a new reference.
+    #
+    # @return [Boolean]
+    def new_reference?
+      return Erlang.is_list(@ids)
+    end
+
+    # Return the contents of this `reference` as a Erlang-readable `::String`.
+    #
+    # @example
+    #     # New reference
+    #     Erlang::Reference["nonode@nohost", 0, [0, 0, 0]].erlang_inspect
+    #     # => "{'reference','nonode@nohost',0,[0,0,0]}"
+    #     # Old reference
+    #     Erlang::Reference["nonode@nohost", 0, 0].erlang_inspect
+    #     # => "{'reference','nonode@nohost',0,0}"
+    #
+    # @return [::String]
+    def erlang_inspect(raw = false)
+      if raw == true and Erlang.respond_to?(:term_to_binary)
+        result = 'erlang:binary_to_term('
+        result << Erlang.inspect(Erlang.term_to_binary(self), raw: raw)
+        result << ')'
+        return result
+      else
+        return Erlang.inspect(Erlang::Tuple[:reference, @node, @creation, @ids], raw: raw)
+      end
+    end
+
+    # @return [::String] the nicely formatted version of the `Reference`
+    def inspect
+      return "Erlang::Reference[#{@node.inspect}, #{@creation.inspect}, #{@ids.inspect}]"
+    end
+
+    # @return [::Array]
+    # @private
+    def marshal_dump
+      return [@node, @creation, @ids]
+    end
+
+    # @private
+    def marshal_load(args)
+      node, creation, ids = args
+      initialize(node, creation, ids)
+      __send__(:immutable!)
+      return self
+    end
+  end
+end