schmurfy-bert 1.2.3

data/bert.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{schmurfy-bert}
+  s.version = "1.2.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tom Preston-Werner"]
+  s.date = %q{2010-12-07}
+  s.description = %q{BERT Serializiation for Ruby}
+  s.email = %q{tom@mojombo.com}
+  s.extensions = ["ext/bert/c/extconf.rb", "ext/bert/c/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bench/bench.rb",
+     "bench/decode_bench.rb",
+     "bench/encode_bench.rb",
+     "bench/results.txt",
+     "bert.gemspec",
+     "ext/bert/c/extconf.rb",
+     "lib/bert.rb",
+     "lib/bert/bert.rb",
+     "lib/bert/decode.rb",
+     "lib/bert/decoder.rb",
+     "lib/bert/encode.rb",
+     "lib/bert/encoder.rb",
+     "lib/bert/terms.rb",
+     "lib/bert/types.rb",
+     "test/bert_test.rb",
+     "test/decoder_test.rb",
+     "test/encoder_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mojombo/bert}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib", "ext"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{BERT Serializiation for Ruby}
+  s.test_files = [
+    "test/bert_test.rb",
+     "test/decoder_test.rb",
+     "test/encoder_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/ext/bert/c/extconf.rb

@@ -0,0 +1,11 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'decode'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/lib/bert.rb

@@ -0,0 +1,20 @@
+
+require 'stringio'
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
+
+require 'bert/bert'
+require 'bert/types'
+require 'bert/terms'
+
+require 'bert/decode'
+
+require 'bert/encode'
+
+require 'bert/encoder'
+require 'bert/decoder'
+
+# Global method for specifying that an array should be encoded as a tuple.
+def t
+  BERT::Tuple
+end

data/lib/bert/bert.rb

@@ -0,0 +1,21 @@
+module BERT
+  def self.encode(ruby)
+    Encoder.encode(ruby)
+  end
+
+  def self.decode(bert)
+    Decoder.decode(bert)
+  end
+
+  def self.ebin(str)
+    bytes = []
+    str.each_byte { |b| bytes << b.to_s }
+    "<<" + bytes.join(',') + ">>"
+  end
+
+  class Tuple < Array
+    def inspect
+      "t#{super}"
+    end
+  end
+end

data/lib/bert/decode.rb

@@ -0,0 +1,269 @@
+module BERT
+  class Decode
+    attr_accessor :in
+    include Types
+    include Terms
+
+    def self.impl
+      'Ruby'
+    end
+
+    def self.decode(string)
+      new(StringIO.new(string)).read_any
+    end
+
+    def initialize(ins)
+      @in = ins
+      @peeked = ""
+    end
+
+    def read_any
+      fail("Bad Magic") unless read_1 == MAGIC
+      read_any_raw
+    end
+
+    def read_any_raw
+      case peek_1
+        when ATOM then read_atom
+        when SMALL_INT then read_small_int
+        when INT then read_int
+        when SMALL_BIGNUM then read_small_bignum
+        when LARGE_BIGNUM then read_large_bignum
+        when FLOAT then read_float
+        when SMALL_TUPLE then read_small_tuple
+        when LARGE_TUPLE then read_large_tuple
+        when NIL then read_nil
+        when STRING then read_erl_string
+        when LIST then read_list
+        when BIN then read_bin
+        when PID then read_pid
+        else
+          fail("Unknown term tag: #{peek_1}")
+      end
+    end
+
+    def read(length)
+      if length < @peeked.length
+        result = @peeked[0...length]
+        @peeked = @peeked[length..-1]
+        length = 0
+      else
+        result = @peeked
+        @peeked = ''
+        length -= result.length
+      end
+
+      if length > 0
+        result << @in.read(length)
+      end
+      result.force_encoding('UTF-8')
+    end
+
+    def peek(length)
+      if length <= @peeked.length
+        @peeked[0...length]
+      else
+        read_bytes = @in.read(length - @peeked.length)
+        @peeked << read_bytes if read_bytes
+        @peeked
+      end
+    end
+
+    def peek_1
+      peek(1).unpack("C").first
+    end
+
+    def peek_2
+      peek(2).unpack("n").first
+    end
+
+    def read_1
+      read(1).unpack("C").first
+    end
+
+    def read_2
+      read(2).unpack("n").first
+    end
+
+    def read_4
+      read(4).unpack("N").first
+    end
+
+    def read_string(length)
+      read(length)
+    end
+
+    def read_atom
+      fail("Invalid Type, not an atom") unless read_1 == ATOM
+      length = read_2
+      a = read_string(length)
+      case a
+        when ""
+          Marshal.load("\004\b:\005") # Workaround for inability to do ''.to_sym
+        else
+          a.to_sym
+      end
+    end
+
+    def read_small_int
+      fail("Invalid Type, not a small int") unless read_1 == SMALL_INT
+      read_1
+    end
+
+    def read_int
+      fail("Invalid Type, not an int") unless read_1 == INT
+      value = read_4
+      negative = (value >> 31)[0] == 1
+      value = (value - (1 << 32)) if negative
+      attempt_cast(Fixnum, value)
+    end
+
+    def read_small_bignum
+      fail("Invalid Type, not a small bignum") unless read_1 == SMALL_BIGNUM
+      size = read_1
+      sign = read_1
+      bytes = read_string(size).unpack("C" * size)
+      added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index|
+        byte, index = *byte_index
+        value = (byte * (256 ** index))
+        sign != 0 ? (result - value) : (result + value)
+      end
+      attempt_cast(Bignum, added)
+    end
+
+    def read_large_bignum
+      fail("Invalid Type, not a large bignum") unless read_1 == LARGE_BIGNUM
+      size = read_4
+      sign = read_1
+      bytes = read_string(size).unpack("C" * size)
+      added = bytes.zip((0..bytes.length).to_a).inject(0) do |result, byte_index|
+        byte, index = *byte_index
+        value = (byte * (256 ** index))
+        sign != 0 ? (result - value) : (result + value)
+      end
+      attempt_cast(Bignum, added)
+    end
+
+    def read_float
+      fail("Invalid Type, not a float") unless read_1 == FLOAT
+      string_value = read_string(31)
+      result = string_value.to_f
+    end
+
+    def read_small_tuple
+      fail("Invalid Type, not a small tuple") unless read_1 == SMALL_TUPLE
+      read_tuple(read_1)
+    end
+
+    def read_large_tuple
+      fail("Invalid Type, not a small tuple") unless read_1 == LARGE_TUPLE
+      read_tuple(read_4)
+    end
+
+    def read_tuple(arity)
+      if arity > 0
+        tag = read_any_raw
+        if tag == :bert
+          read_complex_type(arity)
+        else
+          tuple = Tuple.new(arity)
+          tuple[0] = tag
+          (arity - 1).times { |i| tuple[i + 1] = read_any_raw }
+          tuple
+        end
+      else
+        Tuple.new
+      end
+    end
+
+    def read_complex_type(arity)
+      case read_any_raw
+        when :nil
+          nil
+        when :true
+          true
+        when :false
+          false
+        when :time
+          Time.at(read_any_raw * 1_000_000 + read_any_raw, read_any_raw)
+        when :regex
+          source = read_any_raw
+          opts = read_any_raw
+          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)
+        when :dict
+          read_dict
+        else
+          nil
+      end
+    end
+
+    def read_dict
+      type = read_1
+      fail("Invalid dict spec, not an erlang list") unless [LIST, NIL].include?(type)
+      if type == LIST
+        length = read_4
+      else
+        length = 0
+      end
+      hash = {}
+      length.times do |i|
+        pair = read_any_raw
+        hash[pair[0]] = pair[1]
+      end
+      read_1 if type == LIST
+      hash
+    end
+
+    def read_nil
+      fail("Invalid Type, not a nil list") unless read_1 == NIL
+      []
+    end
+
+    def read_erl_string
+      fail("Invalid Type, not an erlang string") unless read_1 == STRING
+      length = read_2
+      read_string(length).unpack('C' * length)
+    end
+
+    def read_list
+      fail("Invalid Type, not an erlang list") unless read_1 == LIST
+      length = read_4
+      list = (0...length).map { |i| read_any_raw }
+      read_1
+      list
+    end
+
+    def read_bin
+      fail("Invalid Type, not an erlang binary") unless read_1 == BIN
+      length = read_4
+      read_string(length)
+    end
+
+    def read_pid
+      fail("Invalid Type, not a pid") unless read_1 == PID
+      node = read_atom
+      id = read_4
+      serial = read_4
+      creation = read_1
+      Pid.new(node, id, serial, creation)
+    end
+
+    def fail(str)
+      raise str
+    end
+
+    private
+
+    def attempt_cast(klass, value)
+      if klass.respond_to?(:induced_from)
+        klass.induced_from(value)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/bert/decoder.rb

@@ -0,0 +1,11 @@
+module BERT
+  class Decoder
+    # Decode a BERT into a Ruby object.
+    #   +bert+ is the BERT String
+    #
+    # Returns a Ruby object
+    def self.decode(bert)
+      Decode.decode(bert)
+    end
+  end
+end

data/lib/bert/encode.rb

@@ -0,0 +1,178 @@
+module BERT
+  class Encode
+    include Types
+    include Terms
+
+    attr_accessor :out
+
+    def initialize(out)
+      self.out = out
+    end
+
+    def self.encode(data)
+      io = StringIO.new
+      self.new(io).write_any(data)
+
+      # set correct encoding type
+      if io.string.respond_to?(:force_encoding)
+        io.string.force_encoding("ASCII-8BIT")
+      else
+        io.string
+      end
+    end
+
+    def write_any obj
+      write_1 MAGIC
+      write_any_raw obj
+    end
+
+    def write_any_raw obj
+      case obj
+        when Symbol then write_symbol(obj)
+        when Fixnum, Bignum then write_fixnum(obj)
+        when Float then write_float(obj)
+        when Tuple then write_tuple(obj)
+        when Array then write_list(obj)
+        when String then write_binary(obj)
+        when Pid then write_pid(obj)
+        else
+          fail(obj)
+      end
+    end
+
+    def self.write_byte(byte)
+      [byte].pack("C")
+    end
+
+    def write_1(byte)
+      out.write(
+        self.class.write_byte(byte)
+      )
+    end
+
+    def self.write_short(short)
+      [short].pack("n")
+    end
+
+    def write_2(short)
+      out.write(
+        self.class.write_short(short)
+      )
+    end
+
+    def self.write_long(long)
+      [long].pack("N")
+    end
+
+    def write_4(long)
+      out.write(
+        self.class.write_long(long)
+      )
+    end
+
+    def self.write_string(string)
+      string
+    end
+
+    def write_string(string)
+      out.write(
+        self.class.write_string(string)
+      )
+    end
+
+    def write_boolean(bool)
+      write_symbol(bool.to_s.to_sym)
+    end
+
+    def write_pid(pid)
+      write_1(PID)
+      write_symbol(pid.node)
+      write_4((pid.node_id & 0x7fff))
+      write_4((pid.serial & 0x1fff))
+      write_1((pid.creation & 0x3))
+    end
+
+    def write_symbol(sym)
+      fail(sym) unless sym.is_a?(Symbol)
+      data = sym.to_s
+      write_1 ATOM
+      write_2 data.length
+      write_string data
+    end
+
+    def write_fixnum(num)
+      if num >= 0 && num < 256
+        write_1 SMALL_INT
+        write_1 num
+      elsif num <= MAX_INT && num >= MIN_INT
+        write_1 INT
+        write_4 num
+      else
+        write_bignum num
+      end
+    end
+
+    def write_float(float)
+      write_1 FLOAT
+      write_string format("%15.15e", float).ljust(31, "\000")
+    end
+
+    def write_bignum(num)
+      n = (num.to_s(2).size / 8.0).ceil
+      if n < 256
+        write_1 SMALL_BIGNUM
+        write_1 n
+        write_bignum_guts(num)
+      else
+        write_1 LARGE_BIGNUM
+        write_4 n
+        write_bignum_guts(num)
+      end
+    end
+
+    def write_bignum_guts(num)
+      write_1 (num >= 0 ? 0 : 1)
+      num = num.abs
+      while num != 0
+        rem = num % 256
+        write_1 rem
+        num = num >> 8
+      end
+    end
+
+    def write_tuple(data)
+      fail(data) unless data.is_a? Array
+
+      if data.length < 256
+        write_1 SMALL_TUPLE
+        write_1 data.length
+      else
+        write_1 LARGE_TUPLE
+        write_4 data.length
+      end
+
+      data.each { |e| write_any_raw e }
+    end
+
+    def write_list(data)
+      fail(data) unless data.is_a? Array
+      write_1 NIL and return if data.empty?
+      write_1 LIST
+      write_4 data.length
+      data.each{|e| write_any_raw e }
+      write_1 NIL
+    end
+
+    def write_binary(data)
+      write_1 BIN
+      write_4 data.bytes.count
+      write_string data
+    end
+
+    private
+
+    def fail(obj)
+      raise "Cannot encode to erlang external format: #{obj.inspect}"
+    end
+  end
+end