bert 1.0.0 → 1.1.0

data/lib/bert/encoder.rb

@@ -6,38 +6,37 @@ module BERT
     # Returns a BERT
     def self.encode(ruby)
       complex_ruby = convert(ruby)
-      Erlectricity::Encoder.encode(complex_ruby)
+      Encode.encode(complex_ruby)
     end
 
-    # Convert Ruby types into corresponding Erlectricity representation
-    # of BERT complex types.
+    # Convert complex Ruby form in simple Ruby form.
     #   +item+ is the Ruby object to convert
     #
     # Returns the converted Ruby object
     def self.convert(item)
       case item
         when Hash
-          pairs = Erl::List[]
-          item.each_pair { |k, v| pairs << [convert(k), convert(v)] }
-          [:bert, :dict, pairs]
+          pairs = []
+          item.each_pair { |k, v| pairs << t[convert(k), convert(v)] }
+          t[:bert, :dict, pairs]
         when Tuple
-          item.map { |x| convert(x) }
+          Tuple.new(item.map { |x| convert(x) })
         when Array
-          Erl::List.new(item.map { |x| convert(x) })
+          item.map { |x| convert(x) }
         when nil
-          [:bert, :nil]
+          t[:bert, :nil]
         when TrueClass
-          [:bert, :true]
+          t[:bert, :true]
         when FalseClass
-          [:bert, :false]
+          t[:bert, :false]
         when Time
-          [:bert, :time, item.to_i / 1_000_000, item.to_i % 1_000_000, item.usec]
+          t[:bert, :time, item.to_i / 1_000_000, item.to_i % 1_000_000, item.usec]
         when Regexp
-          options = Erl::List[]
+          options = []
           options << :caseless if item.options & Regexp::IGNORECASE > 0
           options << :extended if item.options & Regexp::EXTENDED > 0
           options << :multiline if item.options & Regexp::MULTILINE > 0
-          [:bert, :regex, item.source, options]
+          t[:bert, :regex, item.source, options]
         else
           item
       end

data/lib/bert/types.rb

@@ -0,0 +1,21 @@
+module BERT
+  module Types
+    SMALL_INT = 97
+    INT = 98
+    SMALL_BIGNUM = 110
+    LARGE_BIGNUM = 111
+    FLOAT = 99
+    ATOM = 100
+    SMALL_TUPLE = 104
+    LARGE_TUPLE = 105
+    NIL = 106
+    STRING = 107
+    LIST = 108
+    BIN = 109
+    FUN = 117
+    NEW_FUN = 112
+    MAGIC = 131
+    MAX_INT = (1 << 27) -1
+    MIN_INT = -(1 << 27)
+  end
+end

data/test/decoder_test.rb

@@ -1,64 +1,91 @@
 require 'test_helper'
 
 class DecoderTest < Test::Unit::TestCase
+  BERT_NIL = [131,104,2,100,0,4,98,101,114,116,100,0,3,110,105,108].pack('c*')
+  BERT_TRUE = [131,104,2,100,0,4,98,101,114,116,100,0,4,116,114,117,101].pack('c*')
+  BERT_FALSE = [131,104,2,100,0,4,98,101,114,116,100,0,5,102,97,108,115,101].pack('c*')
+
   context "BERT Decoder complex type converter" do
     should "convert nil" do
-      before = [:bert, :nil]
-      after = nil
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal nil, BERT::Decoder.decode(BERT_NIL)
     end
 
     should "convert nested nil" do
-      before = [[:bert, :nil], [[:bert, :nil]]]
-      after = [nil, [nil]]
-      assert_equal after, BERT::Decoder.convert(before)
+      bert = [131,108,0,0,0,2,104,2,100,0,4,98,101,114,116,100,0,3,110,105,
+              108,108,0,0,0,1,104,2,100,0,4,98,101,114,116,100,0,3,110,105,
+              108,106,106].pack('c*')
+      assert_equal [nil, [nil]], BERT::Decoder.decode(bert)
     end
 
     should "convert hashes" do
-      before = [:bert, :dict, [[:foo, 'bar']]]
+      bert = [131,104,3,100,0,4,98,101,114,116,100,0,4,100,105,99,116,108,
+              0,0,0,1,104,2,100,0,3,102,111,111,109,0,0,0,3,98,97,114,
+              106].pack('c*')
       after = {:foo => 'bar'}
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal after, BERT::Decoder.decode(bert)
     end
 
     should "convert empty hashes" do
-      before = [:bert, :dict, []]
+      bert = [131,104,3,100,0,4,98,101,114,116,100,0,4,100,105,99,116,
+              106].pack('c*')
       after = {}
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal after, BERT::Decoder.decode(bert)
     end
 
     should "convert nested hashes" do
-      before = [:bert, :dict, [[:foo, [:bert, :dict, [[:baz, 'bar']]]]]]
+      bert = [131,104,3,100,0,4,98,101,114,116,100,0,4,100,105,99,116,108,0,
+              0,0,1,104,2,100,0,3,102,111,111,104,3,100,0,4,98,101,114,116,
+              100,0,4,100,105,99,116,108,0,0,0,1,104,2,100,0,3,98,97,122,109,
+              0,0,0,3,98,97,114,106,106].pack('c*')
       after = {:foo => {:baz => 'bar'}}
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal after, BERT::Decoder.decode(bert)
     end
 
     should "convert true" do
-      before = [:bert, true]
-      after = true
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal true, BERT::Decoder.decode(BERT_TRUE)
     end
 
     should "convert false" do
-      before = [:bert, false]
-      after = false
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal false, BERT::Decoder.decode(BERT_FALSE)
     end
 
     should "convert times" do
-      before = [:bert, :time, 1254, 976067, 0]
+      bert = [131,104,5,100,0,4,98,101,114,116,100,0,4,116,105,109,101,98,0,
+              0,4,230,98,0,14,228,195,97,0].pack('c*')
       after = Time.at(1254976067)
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal after, BERT::Decoder.decode(bert)
     end
 
     should "convert regexen" do
-      before = [:bert, :regex, '^c(a)t$', [:caseless, :extended]]
+      bert = [131,104,4,100,0,4,98,101,114,116,100,0,5,114,101,103,101,120,
+              109,0,0,0,7,94,99,40,97,41,116,36,108,0,0,0,2,100,0,8,99,97,
+              115,101,108,101,115,115,100,0,8,101,120,116,101,110,100,101,
+              100,106].pack('c*')
       after = /^c(a)t$/ix
-      assert_equal after, BERT::Decoder.convert(before)
+      assert_equal after, BERT::Decoder.decode(bert)
     end
 
     should "leave other stuff alone" do
-      before = [1, 2.0, [:foo, 'bar']]
-      assert_equal before, BERT::Decoder.convert(before)
+      bert = [131,108,0,0,0,3,97,1,99,50,46,48,48,48,48,48,48,48,48,48,48,48,
+              48,48,48,48,48,48,48,48,48,101,43,48,48,0,0,0,0,0,108,0,0,0,2,
+              100,0,3,102,111,111,109,0,0,0,3,98,97,114,106,106].pack('c*')
+      after = [1, 2.0, [:foo, 'bar']]
+      assert_equal after, BERT::Decoder.decode(bert)
+    end
+
+    should "handle bignums" do
+      bert = [131,110,8,0,0,0,232,137,4,35,199,138].pack('c*')
+      assert_equal 10_000_000_000_000_000_000, BERT::Decoder.decode(bert)
+    end
+
+    should "handle bytelists" do
+      bert = [131,104,3,100,0,3,102,111,111,107,0,2,97,97,100,0,3,98,97,114].pack('c*')
+      assert_equal t[:foo, [97, 97], :bar], BERT::Decoder.decode(bert)
+    end
+
+    should "handle massive binaries" do
+      bert = [131,109,0,128,0,0].pack('c*') + ('a' * (8 * 1024 * 1024))
+      assert_equal (8 * 1024 * 1024), BERT::Decoder.decode(bert).size
     end
   end
 end

data/test/encoder_test.rb

@@ -27,7 +27,7 @@ class EncoderTest < Test::Unit::TestCase
     should "convert hash to tuple with array of tuples" do
       arr = BERT::Encoder.convert({:foo => 'bar'})
       assert arr.is_a?(Array)
-      assert arr[2].is_a?(Erl::List)
+      assert arr[2].is_a?(Array)
       assert arr[2][0].is_a?(Array)
     end
 
@@ -38,13 +38,13 @@ class EncoderTest < Test::Unit::TestCase
 
     should "convert array to erl list" do
       list = BERT::Encoder.convert([1, 2])
-      assert list.is_a?(Erl::List)
+      assert list.is_a?(Array)
     end
 
     should "convert an array in a tuple" do
       arrtup = BERT::Encoder.convert(t[:foo, [1, 2]])
       assert arrtup.is_a?(Array)
-      assert arrtup[1].is_a?(Erl::List)
+      assert arrtup[1].is_a?(Array)
     end
 
     should "convert true" do
@@ -74,9 +74,14 @@ class EncoderTest < Test::Unit::TestCase
     should "properly convert types" do
       ruby = t[:user, {:name => 'TPW'}, [/cat/i, 9.9], nil, true, false, :true, :false]
       cruby = BERT::Encoder.convert(ruby)
-      assert cruby.instance_of?(Array)
+      assert cruby.instance_of?(BERT::Tuple)
       assert cruby[0].instance_of?(Symbol)
-      assert cruby[1].instance_of?(Array)
+      assert cruby[1].instance_of?(BERT::Tuple)
+    end
+
+    should "handle bignums" do
+      bert = [131,110,8,0,0,0,232,137,4,35,199,138].pack('c*')
+      assert_equal bert, BERT::Encoder.encode(10_000_000_000_000_000_000)
     end
 
     should "leave other stuff alone" do

data/test/test_helper.rb

@@ -5,15 +5,4 @@ require 'shoulda'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'bert'
-
-class Test::Unit::TestCase
-end
-
-# So I can easily see which arrays are Erl::List
-module Erl
-  class List
-    def inspect
-      "l#{super}"
-    end
-  end
-end
+puts "Using #{BERT::Decode.impl} implementation."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bert
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -9,19 +9,9 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-19 00:00:00 -07:00
+date: 2009-10-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: erlectricity
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.1.0
-    version: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
   type: :development
@@ -36,8 +26,8 @@ description: BERT Serializiation for Ruby
 email: tom@mojombo.com
 executables: []
 
-extensions: []
-
+extensions: 
+- ext/bert/c/extconf.rb
 extra_rdoc_files: 
 - LICENSE
 - README.md
@@ -49,10 +39,20 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- bench/bench.rb
+- bench/decode_bench.rb
+- bench/encode_bench.rb
+- bench/results.txt
 - bert.gemspec
+- ext/bert/c/decode.c
+- 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/types.rb
 - test/bert_test.rb
 - test/decoder_test.rb
 - test/encoder_test.rb
@@ -66,6 +66,7 @@ rdoc_options:
 - --charset=UTF-8
 require_paths: 
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="