erlang-terms 1.1.0 → 2.0.1

data/lib/erlang/cons.rb

@@ -0,0 +1,122 @@
+module Erlang
+  # The basic building block for constructing lists
+  #
+  # A Cons, also known as a "cons cell", has a "head" and a "tail", where
+  # the head is an element in the list, and the tail is a reference to the
+  # rest of the list. This way a singly linked list can be constructed, with
+  # each `Erlang::Cons` holding a single element and a pointer to the next
+  # `Erlang::Cons`.
+  #
+  # The last `Erlang::Cons` instance in the chain has the {Erlang::Nil} as its tail.
+  #
+  # 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 Cons
+    include Erlang::Term
+    include Erlang::List
+    include Erlang::Immutable
+
+    attr_reader :head
+
+    attr_reader :tail
+
+    class << self
+      def inspect
+        return Erlang::List.inspect
+      end
+
+      def pretty_inspect
+        return Erlang::List.pretty_inspect
+      end
+
+      def pretty_print(q)
+        return Erlang::List.pretty_print(q)
+      end
+    end
+
+    def initialize(head, tail = Erlang::Nil)
+      @head = Erlang.from(head)
+      @tail = Erlang.from(tail)
+      @improper = @tail.kind_of?(Erlang::List) ? @tail.improper? : true
+    end
+
+    def empty?
+      return false
+    end
+
+    def improper?
+      return !!@improper
+    end
+
+    # Return the number of items in this `Erlang::List`.
+    # @return [Integer]
+    def size
+      raise Erlang::ImproperListError if improper?
+      return 0 if empty?
+      size = 0
+      list = self
+      until list.empty?
+        list = list.tail
+        size += 1
+      end
+      return size
+    end
+    memoize :size
+    alias :length :size
+
+    # @return [::Array]
+    # @private
+    def marshal_dump
+      if improper?
+        return [to_proper_list.to_a, last(true)]
+      else
+        return [to_a, Erlang::Nil]
+      end
+    end
+
+    # @private
+    def marshal_load(args)
+      h, t = args
+      if h.size == 0
+        return t
+      elsif Erlang::Nil.eql?(t)
+        head = h[0]
+        tail = Erlang::List.from_enum(h[1..-1])
+        initialize(head, tail)
+        __send__(:immutable!)
+        return self
+      else
+        head = h[0]
+        tail = Erlang::List.from_enum(h[1..-1]) + t
+        initialize(head, tail)
+        __send__(:immutable!)
+        return self
+      end
+    end
+  end
+end

data/lib/erlang/enumerable.rb

@@ -0,0 +1,160 @@
+module Erlang
+  # Helper module for Erlang sequential collections
+  #
+  # Classes including `Erlang::Enumerable` must implement:
+  #
+  # - `#each` (just like `::Enumerable`).
+  # - `#select`, which takes a block, and returns an instance of the same class
+  #     with only the items for which the block returns a true value
+  #
+  # 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.
+  #
+  module Enumerable
+    include ::Enumerable
+
+    # Return a new collection with all the elements for which the block returns false.
+    def reject
+      return enum_for(:reject) if not block_given?
+      return select { |item| !yield(item) }
+    end
+    alias :delete_if :reject
+
+    # Return a new collection with all `nil` elements removed.
+    def compact
+      return select { |item| !item.nil? }
+    end
+
+    # Search the collection for elements which are `#===` to `item`. Yield them to
+    # the optional code block if provided, and return them as a new collection.
+    def grep(pattern, &block)
+      result = select { |item| pattern === item }
+      result = result.map(&block) if block_given?
+      return result
+    end
+
+    # Search the collection for elements which are not `#===` to `item`. Yield
+    # them to the optional code block if provided, and return them as a new
+    # collection.
+    def grep_v(pattern, &block)
+      result = select { |item| !(pattern === item) }
+      result = result.map(&block) if block_given?
+      return result
+    end
+
+    # Yield all integers from 0 up to, but not including, the number of items in
+    # this collection. For collections which provide indexed access, these are all
+    # the valid, non-negative indices into the collection.
+    def each_index(&block)
+      return enum_for(:each_index) unless block_given?
+      0.upto(size-1, &block)
+      return self
+    end
+
+    # Multiply all the items (presumably numeric) in this collection together.
+    def product
+      return reduce(1, &:*)
+    end
+
+    # Add up all the items (presumably numeric) in this collection.
+    def sum
+      return reduce(0, &:+)
+    end
+
+    # Return 2 collections, the first containing all the elements for which the block
+    # evaluates to true, the second containing the rest.
+    def partition
+      return enum_for(:partition) if not block_given?
+      a,b = super
+      return Erlang::Tuple[self.class.new(a), self.class.new(b)]
+    end
+
+    # Groups the collection into sub-collections by the result of yielding them to
+    # the block. Returns a {Map} where the keys are return values from the block,
+    # and the values are sub-collections. All the sub-collections are built up from
+    # `empty_group`, which should respond to `#add` by returning a new collection
+    # with an added element.
+    def group_by_with(empty_group, &block)
+      block ||= lambda { |item| item }
+      return reduce(EmptyMap) do |map, item|
+        key = block.call(item)
+        group = map.get(key) || empty_group
+        map.put(key, group.add(item))
+      end
+    end
+    protected :group_by_with
+
+    # Groups the collection into sub-collections by the result of yielding them to
+    # the block. Returns a {Map} where the keys are return values from the block,
+    # and the values are sub-collections (of the same type as this one).
+    def group_by(&block)
+      return group_by_with(self.class.empty, &block)
+    end
+
+    # Convert all the elements into strings and join them together, separated by
+    # `separator`. By default, the `separator` is `$,`, the global default string
+    # separator, which is normally `nil`.
+    def join(separator = $,)
+      result = ""
+      if separator
+        each_with_index { |obj, i| result << separator if i > 0; result << obj.to_s }
+      else
+        each { |obj| result << obj.to_s }
+      end
+      return Erlang.from(result)
+    end
+
+    # Convert this collection to a programmer-readable `String` representation.
+    def inspect
+      result = "#{self.class}["
+      each_with_index { |obj, i| result << ', ' if i > 0; result << obj.inspect }
+      return result << "]"
+    end
+
+    # @private
+    def pretty_print(pp)
+      return pp.group(1, "#{self.class}[", "]") do
+        pp.breakable ''
+        pp.seplist(self) { |obj| obj.pretty_print(pp) }
+      end
+    end
+
+    alias :to_ary :to_a
+    alias :index :find_index
+
+    ## Compatibility fixes
+
+    if RUBY_ENGINE == 'rbx'
+      # Rubinius implements Enumerable#sort_by using Enumerable#map
+      # Because we do our own, custom implementations of #map, that doesn't work well
+      # @private
+      def sort_by(&block)
+        result = Erlang.from(to_a)
+        return result.frozen? ? result.sort_by(&block) : result.sort_by!(&block)
+      end
+    end
+  end
+end

data/lib/erlang/error.rb

@@ -0,0 +1,4 @@
+module Erlang
+  # @private
+  class Error < StandardError; end
+end

data/lib/erlang/export.rb

@@ -1,23 +1,121 @@
 module Erlang
+  # An `Export` is an external function.  It corresponds to the `fun M:F/A` syntax from Erlang.
+  #
+  # ### Creating Exports
+  #
+  #     Erlang::Export[:erlang, :make_ref, 0]
+  #     # => Erlang::Export[:erlang, :make_ref, 0]
+  #
   class Export
-    attr_accessor :mod, :function, :arity
+    include Erlang::Term
+    include Erlang::Immutable
 
+    # Return the module for this `Export`
+    # @return [Atom]
+    attr_reader :mod
+
+    # Return the function for this `Export`
+    # @return [Atom]
+    attr_reader :function
+
+    # Return the arity for this `Export`
+    # @return [Integer]
+    attr_reader :arity
+
+    class << self
+      # Create a new `Export` populated with the given `mod`, `function`, and `arity`.
+      # @param mod [Atom, Symbol] The module atom
+      # @param function [Atom, Symbol] The function atom
+      # @param arity [Integer] The arity of the function
+      # @return [Export]
+      # @raise [ArgumentError] if `arity` is not an `Integer`
+      def [](mod, function, arity)
+        return new(mod, function, arity)
+      end
+
+      # Compares `a` and `b` and returns whether they are less than,
+      # equal to, or greater than each other.
+      #
+      # @param a [Export] The left argument
+      # @param b [Export] The right argument
+      # @return [-1, 0, 1]
+      # @raise [ArgumentError] if `a` or `b` is not an `Export`
+      def compare(a, b)
+        raise ArgumentError, "'a' must be of Erlang::Export type" unless a.kind_of?(Erlang::Export)
+        raise ArgumentError, "'b' must be of Erlang::Export type" unless b.kind_of?(Erlang::Export)
+        c = Erlang.compare(a.mod, b.mod)
+        return c if c != 0
+        c = Erlang.compare(a.function, b.function)
+        return c if c != 0
+        c = Erlang.compare(a.arity, b.arity)
+        return c
+      end
+    end
+
+    # @private
     def initialize(mod, function, arity)
-      self.mod      = mod
-      self.function = function
-      self.arity    = arity
+      raise ArgumentError, 'arity must be a non-negative Integer' if not arity.is_a?(::Integer) or arity < 0
+      @mod = Erlang::Atom[mod]
+      @function = Erlang::Atom[function]
+      @arity = arity.freeze
+    end
+
+    # Return true if `other` has the same type and contents as this `Export`.
+    #
+    # @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 !!(mod == other.mod &&
+          function == other.function &&
+          arity == other.arity)
+      else
+        return !!(Erlang.compare(other, self) == 0)
+      end
+    end
+    alias :== :eql?
+
+    # Return the contents of this `Export` as a Erlang-readable `::String`.
+    #
+    # @example
+    #     Erlang::Export[:erlang, :make_ref, 0].erlang_inspect
+    #     # => "fun 'erlang':'make_ref'/0"
+    #
+    # @return [::String]
+    def erlang_inspect(raw = false)
+      result = 'fun '
+      result << Erlang.inspect(@mod, raw: raw)
+      result << ':'
+      result << Erlang.inspect(@function, raw: raw)
+      result << '/'
+      result << Erlang.inspect(@arity, raw: raw)
+      return result
     end
 
-    # @return [String] the nicely formatted version of the message
+    # @return [::String] the nicely formatted version of the `Export`.
     def inspect
-      "#<#{self.class.name} fun #{mod}:#{function}/#{arity}>"
+      return "Erlang::Export[#{mod.inspect}, #{function.inspect}, #{arity.inspect}]"
+    end
+
+    # @private
+    def hash
+      state = [@mod, @function, @arity]
+      return state.reduce(Erlang::Export.hash) { |acc, item| (acc << 5) - acc + item.hash }
+    end
+
+    # @return [::Array]
+    # @private
+    def marshal_dump
+      return [@mod, @function, @arity]
     end
 
-    def ==(other)
-      self.class === other &&
-      mod.to_s      == other.mod.to_s &&
-      function.to_s == other.function.to_s &&
-      arity         == other.arity
+    # @private
+    def marshal_load(args)
+      mod, function, arity = args
+      initialize(mod, function, arity)
+      __send__(:immutable!)
+      return self
     end
   end
-end
+end

data/lib/erlang/float.rb

@@ -0,0 +1,201 @@
+require 'bigdecimal'
+
+module Erlang
+  # An `Float` is a literal constant float-precision number.
+  #
+  # ### Creating Floats
+  #
+  #     Erlang::Float["1.0e10"]
+  #     # => 1.00000000000000000000e+10
+  #     Erlang::Float[0]
+  #     # => 0.00000000000000000000e+00
+  #     Erlang::Float[-0.0, old: true]
+  #     # => Erlang::Float["-0.00000000000000000000e+00", old: true]
+  #     Erlang::Float[-1e308]
+  #     # => -1.00000000000000000000e+308
+  #     Erlang::Float[1e-308]
+  #     # => 1.00000000000000000000e-308
+  #
+  class Float
+    include Erlang::Term
+    include Erlang::Immutable
+
+    # Return the data for this `Float`
+    # @return [::BigDecimal]
+    attr_reader :data
+
+    # Return the old flag for this `Float`
+    # @return [::Boolean]
+    attr_reader :old
+
+    class << self
+      # Create a new `Float` populated with the given `data`.
+      # @param data [::BigDecimal, ::Float] The content of the `Float`
+      # @param old [Boolean] Whether the `Float` should be considered old or not
+      # @return [Float]
+      # @raise [ArgumentError] if `data` cannot be coerced to be a `::BigDecimal`
+      def [](data, old: false)
+        if data.is_a?(::String)
+          data = ::BigDecimal.new(data)
+        elsif not data.is_a?(::BigDecimal)
+          data = ::BigDecimal.new(data.to_s)
+        end
+        return new(data, old)
+      end
+
+      # Compares `a` and `b` and returns whether they are less than,
+      # equal to, or greater than each other.
+      #
+      # @param a [Float] The left argument
+      # @param b [Float] The right argument
+      # @return [-1, 0, 1]
+      # @raise [ArgumentError] if `a` or `b` is not an `Float`
+      def compare(a, b)
+        raise ArgumentError, "'a' must be of Erlang::Float type" unless a.kind_of?(Erlang::Float)
+        raise ArgumentError, "'b' must be of Erlang::Float type" unless b.kind_of?(Erlang::Float)
+        return a.data <=> b.data
+      end
+    end
+
+    # @private
+    def initialize(data, old)
+      raise ArgumentError, 'data must be a BigDecimal' if not data.is_a?(::BigDecimal)
+      @data = data.freeze
+      @old  = !!old
+      if @old == false and @data != @data.to_f
+        @data = ::BigDecimal.new(@data.to_f.to_s).freeze
+      end
+      raise ArgumentError, "data cannot be positive or negative Infinity: #{data.inspect}" if @data.to_s.include?("Infinity")
+    end
+
+    # @private
+    def hash
+      return @data.hash
+    end
+
+    # If a `numeric` is the same type as `self`, returns an array containing `numeric` and `self`.
+    # Otherwise, returns an array with both a numeric and num represented as `Float` objects.
+    #
+    # @param numeric [Erlang::Float, Numeric]
+    # @return [::Array]
+    def coerce(numeric)
+      if numeric.is_a?(Erlang::Float)
+        return [numeric, self]
+      else
+        return [numeric.to_f, to_f]
+      end
+    end
+
+    # Return true if `other` has the same type and contents as this `Float`.
+    #
+    # @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 !!(self.data == other.data)
+      else
+        return !!(Erlang.compare(other, self) == 0)
+      end
+    end
+    alias :== :eql?
+
+    # Return the contents of this `Float` as a Erlang-readable `::String`.
+    #
+    # @example
+    #     Erlang::Float[-1e308].erlang_inspect
+    #     # => "-1.00000000000000000000e+308"
+    #
+    # @return [::String]
+    def erlang_inspect(raw = false)
+      return to_float_string
+    end
+
+    # @return [::String] the nicely formatted version of the `Float`
+    def inspect
+      if @old
+        return "Erlang::Float[#{to_float_string.inspect}, old: true]"
+      else
+        float_string = to_float_string
+        float_object = ::Kernel::Float(float_string)
+        if Erlang::PositiveInfinity == float_object or Erlang::NegativeInfinity == float_object
+          return "Erlang::Float[#{float_string.inspect}]"
+        else
+          return float_string
+        end
+      end
+    end
+
+    # @return [::String] the float string format of the `Float`
+    def to_float_string
+      string = @data.to_s
+      sign = (string.getbyte(0) == 45) ? '-' : ''
+      offset = (sign.bytesize == 1) ? 1 : 0
+      dotpos = string.index(?.)
+      epos = string.index(?e)
+      if epos.nil?
+        string << "e00"
+        epos = string.index(?e)
+      end
+      if @data.zero?
+        return Erlang::Terms.binary_encoding([
+          sign,
+          '0.00000000000000000000e+00'
+        ].join)
+      end
+      integer = string.byteslice(offset, dotpos - offset)
+      fractional = string.byteslice(dotpos + 1, epos - dotpos - 1)
+      e = string.byteslice(epos + 1, string.bytesize - epos - 1).to_i
+      while fractional.bytesize > 0 and integer == ?0 and e > -323
+        b = fractional.getbyte(0)
+        fractional = fractional.byteslice(1, fractional.bytesize - 1)
+        e -= 1
+        if b != 48
+          integer.setbyte(0, b)
+        end
+      end
+      if fractional.bytesize > 20
+        fractional = fractional.byteslice(0, 20)
+      elsif fractional.bytesize < 20
+        fractional = fractional.ljust(20, ?0)
+      end
+      return Erlang::Terms.binary_encoding([
+        sign,
+        integer,
+        '.',
+        fractional,
+        (e < 0) ? 'e-' : 'e+',
+        e.abs.to_s.rjust(2, ?0)
+      ].join)
+    end
+
+    # @return [::Float] the float version of the `Float`
+    def to_f
+      return @data.to_f
+    end
+
+    # @return [::String] the string version of the `Float`
+    def to_s
+      return to_float_string
+    end
+    alias :to_str :to_s
+
+    # @return [::String]
+    # @private
+    def marshal_dump
+      return [to_float_string, @old]
+    end
+
+    # @private
+    def marshal_load(args)
+      float_string, old = args
+      initialize(::BigDecimal.new(float_string), old)
+      __send__(:immutable!)
+      return self
+    end
+
+  end
+
+  PositiveInfinity = (1.0 / 0.0).freeze
+  NegativeInfinity = -PositiveInfinity
+end