erlang-terms 1.1.0 → 2.0.1

data/lib/erlang/string.rb

@@ -1,7 +1,179 @@
 module Erlang
-  class String < ::String
+  # A `String` is a `List` of characters.
+  #
+  # ### Creating Strings
+  #
+  #     Erlang::String["test"]
+  #     # => Erlang::String["test"]
+  #
+  # A `String` is equivalent to a `List` with `Integer` elements:
+  #
+  #     Erlang::String["test"] == Erlang::List[116, 101, 115, 116]
+  #     # => true
+  #
+  class String
+    include Erlang::Term
+    include Erlang::Immutable
+
+    # Return the data for this `String`
+    # @return [::String]
+    attr_reader :data
+
+    class << self
+      # Create a new `String` populated with the given `data`.
+      # @param data [::String, Symbol, ::Enumerable, Integer] The content of the `Atom`
+      # @return [String]
+      # @raise [ArgumentError] if `data` cannot be coerced to be a `::String`
+      def [](*data)
+        return EmptyString if data.empty?
+        if data.size == 1
+          return data[0] if data[0].kind_of?(Erlang::String)
+        end
+        unless data.is_a?(::String)
+          data = Erlang.iolist_to_binary(data).data
+        end
+        return new(data)
+      end
+
+      # Return an empty `String`. If used on a subclass, returns an empty instance
+      # of that class.
+      #
+      # @return [String]
+      def empty
+        return @empty ||= self.new
+      end
+
+      # Compares `a` and `b` and returns whether they are less than,
+      # equal to, or greater than each other.
+      #
+      # @param a [String] The left argument
+      # @param b [String] The right argument
+      # @return [-1, 0, 1]
+      # @raise [ArgumentError] if `a` or `b` is not a `String`
+      def compare(a, b)
+        raise ArgumentError, "'a' must be of Erlang::String type" if not a.kind_of?(Erlang::String)
+        raise ArgumentError, "'b' must be of Erlang::String type" if not b.kind_of?(Erlang::String)
+        c = a.size <=> b.size
+        return a.data <=> b.data if c == 0
+        return Erlang::List.compare(a.to_list, b.to_list)
+      end
+    end
+
+    # @private
+    def initialize(data = ::String.new.freeze)
+      raise ArgumentError, 'data must be a String' if not data.is_a?(::String)
+      data = Erlang::Terms.binary_encoding(data)
+      @data = data.freeze
+    end
+
+    # @private
+    def hash
+      return to_list.hash
+    end
+
+    # Returns true if this `String` is empty.
+    #
+    # @return [Boolean]
+    def empty?
+      return @data.empty?
+    end
+
+    # Returns an `::Array` with the `::String` data for this `String`.
+    #
+    # @return [[::String]]
+    def flatten
+      return [@data]
+    end
+
+    # Returns the length of this `String`.
+    #
+    # @return [Integer]
+    def length
+      return @data.bytesize
+    end
+    alias :size :length
+
+    # Return true if `other` has the same type and contents as this `String`.
+    #
+    # @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.class.compare(self, other) == 0)
+      else
+        return !!(Erlang.compare(other, self) == 0)
+      end
+    end
+    alias :== :eql?
+
+    # Return the contents of this `String` as a Erlang-readable `::String`.
+    #
+    # @example
+    #     Erlang::String["test"].erlang_inspect
+    #     # => "\"test\""
+    #     # Pass `raw` as `true` for the List version
+    #     Erlang::String["test"].erlang_inspect(true)
+    #     # => "[116,101,115,116]"
+    #
+    # @return [::String]
+    def erlang_inspect(raw = false)
+      if raw == false
+        return @data.inspect
+      else
+        return '[' << @data.bytes.join(',') << ']'
+      end
+    end
+
+    # @return [::String] the nicely formatted version of the `String`
     def inspect
-      "#<#{self.class.name} #{super}>"
+      return "Erlang::String[#{@data.inspect}]"
+    end
+
+    # @return [Atom] the `Atom` version of the `String`
+    def to_atom
+      return Erlang::Atom[@data]
+    end
+
+    # @return [Binary] the `Binary` version of the `String`
+    def to_binary
+      return Erlang::Binary[@data]
+    end
+
+    # @return [List] the `List` version of the `String`
+    def to_list
+      return Erlang::List.from_enum(@data.bytes)
+    end
+
+    # @return [self] the `String` version of the `String`
+    def to_string
+      return self
+    end
+
+    # @return [::String] the string version of the `String`
+    def to_s
+      return @data
+    end
+    alias :to_str :to_s
+
+    # @return [::String]
+    # @private
+    def marshal_dump
+      return @data
+    end
+
+    # @private
+    def marshal_load(data)
+      initialize(data)
+      __send__(:immutable!)
+      return self
     end
   end
-end
+
+  # The canonical empty `Erlang::String`. Returned by `Erlang::String[]` when
+  # invoked with no arguments; also returned by `Erlang::String.empty`. Prefer using this
+  # one rather than creating many empty strings using `Erlang::String.new`.
+  #
+  # @private
+  EmptyString = Erlang::String.empty
+end

data/lib/erlang/term.rb

@@ -0,0 +1,24 @@
+module Erlang
+  # @private
+  module Term
+    class << self
+      # Extends the including class with +ClassMethods+.
+      #
+      # @param [Class] subclass the inheriting class
+      def included(base)
+        super
+        base.extend(ClassMethods)
+        base.send(:include, ::Comparable)
+      end
+
+      private :included
+    end
+
+    module ClassMethods
+    end
+
+    def <=>(other)
+      return Erlang.compare(self, other)
+    end
+  end
+end

data/lib/erlang/terms.rb

@@ -1,14 +1,330 @@
-require "erlang/terms/version"
+require 'erlang/terms/version'
+
+require 'bigdecimal'
+require 'rational'
+
+require 'erlang/undefined'
 
 module Erlang
+  # @private
   module Terms
+    PRINTABLE       = /\A[[:print:]]+\z/.freeze
+    BINARY_ENCODING = Encoding.find('binary')
+    UTF8_ENCODING   = Encoding.find('utf-8')
+    UINT8_SPLAT     = 'C*'.freeze
+    TERM_ORDER      = {
+      number:     0,
+      atom:       1,
+      reference:  2,
+      fun:        3,
+      port:       4,
+      pid:        5,
+      tuple:      6,
+      map:        7,
+      nil:        8,
+      list:       9,
+      bitstring: 10
+    }.freeze
+
+    def self.binary_encoding(string)
+      string = string.dup if string.frozen?
+      string = string.force_encoding(BINARY_ENCODING)
+      return string
+    end
+
+    def self.printable?(string)
+      return !!(PRINTABLE =~ string)
+    end
+
+    def self.utf8_encoding(string)
+      string = string.dup if string.frozen?
+      begin
+        string = string.encode(UTF8_ENCODING)
+      rescue EncodingError
+        string = string.force_encoding(UTF8_ENCODING)
+      end
+      if string.valid_encoding?
+        return true, string
+      else
+        string = binary_encoding(string)
+        return false, string
+      end
+    end
+  end
+
+  def self.compare(a, b)
+    a = Erlang.from(a)
+    b = Erlang.from(b)
+    t = type(a)
+    c = Erlang::Terms::TERM_ORDER[t] <=> Erlang::Terms::TERM_ORDER[type(b)]
+    return c if c != 0
+    case t
+    when :atom
+      return Erlang::Atom.compare(a, b)
+    when :bitstring
+      return Erlang::Bitstring.compare(a, b)
+    when :fun
+      return Erlang::Function.compare(a, b)
+    when :list
+      return Erlang::List.compare(a, b)
+    when :map
+      return Erlang::Map.compare(a, b)
+    when :nil
+      return 0
+    when :number
+      if is_float(a) or is_float(b)
+        af = a
+        if not is_float(a)
+          begin
+            af = Erlang::Float[a]
+          rescue ArgumentError
+            af = a
+          end
+        end
+        bf = b
+        if not is_float(b)
+          begin
+            bf = Erlang::Float[b]
+          rescue ArgumentError
+            bf = b
+          end
+        end
+        return Erlang::Float.compare(af, bf) if af.kind_of?(Erlang::Float) and bf.kind_of?(Erlang::Float)
+        return af.data <=> bf if af.kind_of?(Erlang::Float) and not bf.kind_of?(Erlang::Float)
+        afbfcmp = bf.data <=> af
+        return -afbfcmp
+      end
+      return a <=> b
+    when :pid
+      return Erlang::Pid.compare(a, b)
+    when :port
+      return Erlang::Port.compare(a, b)
+    when :reference
+      return Erlang::Reference.compare(a, b)
+    when :tuple
+      return Erlang::Tuple.compare(a, b)
+    else
+      raise NotImplementedError
+    end
+  end
+
+  def self.from(term)
+    return term.to_erlang if term.respond_to?(:to_erlang)
+    # integer
+    return term if is_integer(term)
+    # float
+    return term if term.kind_of?(Erlang::Float)
+    return Erlang::Float[term] if is_float(term)
+    # atom
+    return term if term.kind_of?(Erlang::Atom)
+    return Erlang::Atom[term] if term.kind_of?(::Symbol)
+    return Erlang::Atom[term] if term.kind_of?(::FalseClass)
+    return Erlang::Atom[term] if term.kind_of?(::NilClass)
+    return Erlang::Atom[term] if term.kind_of?(::TrueClass)
+    # reference, function, port, pid, and tuple
+    return term if is_reference(term)
+    return term if is_function(term)
+    return term if is_port(term)
+    return term if is_pid(term)
+    return term if is_tuple(term)
+    # map
+    return term if term.kind_of?(Erlang::Map)
+    return Erlang::Map[term] if term.kind_of?(::Hash)
+    # nil
+    return term if term.equal?(Erlang::Nil)
+    return Erlang::Nil if is_list(term) and term.empty?
+    # list
+    return term if term.kind_of?(Erlang::List)
+    return term if term.kind_of?(Erlang::String)
+    return Erlang::List.from_enum(term) if term.kind_of?(::Array)
+    # bitstring
+    return term if term.kind_of?(Erlang::Binary)
+    return term if term.kind_of?(Erlang::Bitstring)
+    return Erlang::Binary[term] if term.kind_of?(::String)
+    raise ArgumentError, "unable to convert ruby object of class #{term.class} to erlang term"
+  end
+
+  def self.inspect(term = Erlang::Undefined, raw: false)
+    return super() if Erlang::Undefined.equal?(term)
+    term = from(term)
+    return term.erlang_inspect(raw) if term.respond_to?(:erlang_inspect)
+    return term.inspect if is_any(term)
+    raise NotImplementedError
+  end
+
+  def self.iolist_to_binary(iolist)
+    return iolist if is_binary(iolist)
+    return Erlang::Binary.new(iolist) if iolist.is_a?(::String)
+    return Erlang::Binary.new(iolist.to_s) if iolist.is_a?(::Symbol)
+    if is_list(iolist)
+      return Erlang::Binary.new(iolist.flatten.map do |element|
+        data = nil
+        if element.is_a?(::Integer) and element <= 255 and element >= -256
+          element = element + 256 if element < 0
+          data = element.chr
+        elsif element.is_a?(::String)
+          data = element
+        elsif is_binary(element)
+          data = element.data
+        elsif element.is_a?(::Symbol)
+          data = element.to_s
+        elsif is_list(element)
+          data = iolist_to_binary(element).data
+        else
+          raise ArgumentError, "unknown element in iolist: #{element.inspect}"
+        end
+        next Erlang::Terms.binary_encoding(data)
+      end.join)
+    else
+      raise ArgumentError, "unrecognized iolist: #{iolist.inspect}"
+    end
+  end
+
+  def self.is_any(term)
+    return true if is_atom(term)
+    return true if is_bitstring(term)
+    return true if is_boolean(term)
+    return true if is_float(term)
+    return true if is_function(term)
+    return true if is_integer(term)
+    return true if is_list(term)
+    return true if is_map(term)
+    return true if is_number(term)
+    return true if is_pid(term)
+    return true if is_port(term)
+    return true if is_reference(term)
+    return true if is_tuple(term)
+    return false
+  end
+
+  def self.is_atom(term)
+    return true if term.kind_of?(::Symbol)
+    return true if term.kind_of?(::FalseClass)
+    return true if term.kind_of?(::NilClass)
+    return true if term.kind_of?(::TrueClass)
+    return true if term.kind_of?(Erlang::Atom)
+    return false
+  end
+
+  def self.is_binary(term)
+    return true if term.kind_of?(::String)
+    return true if term.kind_of?(Erlang::Binary)
+    return false
+  end
+
+  def self.is_bitstring(term)
+    return true if is_binary(term)
+    return true if term.kind_of?(Erlang::Bitstring)
+    return false
+  end
+
+  def self.is_boolean(term)
+    return true if term.kind_of?(::FalseClass)
+    return true if term.kind_of?(::TrueClass)
+    return true if term == :true
+    return true if term == :false
+    return false
+  end
+
+  def self.is_float(term)
+    return true if term.kind_of?(::BigDecimal)
+    return true if term.kind_of?(::Float)
+    return true if term.kind_of?(::Rational)
+    return true if term.kind_of?(Erlang::Float)
+    return false
+  end
+
+  def self.is_function(term, arity = nil)
+    if arity == nil
+      return true if term.kind_of?(Erlang::Export)
+      return true if term.kind_of?(Erlang::Function)
+    else
+      return true if is_function(term) and term.arity == arity
+    end
+    return false
+  end
+
+  def self.is_integer(term)
+    return true if term.kind_of?(::Integer)
+    return false
+  end
+
+  def self.is_list(term)
+    return true if term.kind_of?(Erlang::List)
+    return true if term.kind_of?(Erlang::String)
+    return true if term.kind_of?(::Array)
+    return true if term.equal?(Erlang::Nil)
+    return false
+  end
+
+  def self.is_map(term)
+    return true if term.kind_of?(Erlang::Map)
+    return true if term.kind_of?(::Hash)
+    return false
+  end
+
+  def self.is_number(term)
+    return true if is_float(term) or is_integer(term)
+    return false
+  end
+
+  def self.is_pid(term)
+    return true if term.kind_of?(Erlang::Pid)
+    return false
+  end
+
+  def self.is_port(term)
+    return true if term.kind_of?(Erlang::Port)
+    return false
+  end
+
+  def self.is_reference(term)
+    return true if term.kind_of?(Erlang::Reference)
+    return false
+  end
+
+  def self.is_tuple(term)
+    return true if term.kind_of?(Erlang::Tuple)
+    return false
+  end
+
+  def self.type(term)
+    return :atom if is_atom(term)
+    return :bitstring if is_bitstring(term)
+    return :fun if is_function(term)
+    return :list if is_list(term) and not term.empty?
+    return :map if is_map(term)
+    return :nil if is_list(term) and term.empty?
+    return :number if is_number(term)
+    return :pid if is_pid(term)
+    return :port if is_port(term)
+    return :reference if is_reference(term)
+    return :tuple if is_tuple(term)
+    raise NotImplementedError
   end
+
 end
 
-require "erlang/export"
-require "erlang/list"
-require "erlang/map"
-require "erlang/nil"
-require "erlang/pid"
-require "erlang/string"
-require "erlang/tuple"
+require 'erlang/associable'
+require 'erlang/enumerable'
+require 'erlang/immutable'
+
+require 'erlang/error'
+require 'erlang/list'
+require 'erlang/term'
+require 'erlang/trie'
+
+require 'erlang/atom'
+require 'erlang/binary'
+require 'erlang/bitstring'
+require 'erlang/cons'
+require 'erlang/export'
+require 'erlang/float'
+require 'erlang/function'
+require 'erlang/map'
+require 'erlang/nil'
+require 'erlang/pid'
+require 'erlang/port'
+require 'erlang/reference'
+require 'erlang/string'
+require 'erlang/tuple'