schleyfox-bert 1.1.2

data/lib/bert/encoder.rb

@@ -0,0 +1,45 @@
+module BERT
+  class Encoder
+    # Encode a Ruby object into a BERT.
+    #   +ruby+ is the Ruby object
+    #
+    # Returns a BERT
+    def self.encode(ruby)
+      complex_ruby = convert(ruby)
+      Encode.encode(complex_ruby)
+    end
+
+    # 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 = []
+          item.each_pair { |k, v| pairs << t[convert(k), convert(v)] }
+          t[:bert, :dict, pairs]
+        when Tuple
+          Tuple.new(item.map { |x| convert(x) })
+        when Array
+          item.map { |x| convert(x) }
+        when nil
+          t[:bert, :nil]
+        when TrueClass
+          t[:bert, :true]
+        when FalseClass
+          t[:bert, :false]
+        when Time
+          t[:bert, :time, item.to_i / 1_000_000, item.to_i % 1_000_000, item.usec]
+        when Regexp
+          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
+          t[:bert, :regex, item.source, options]
+        else
+          item
+      end
+    end
+  end
+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/bert_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class BertTest < Test::Unit::TestCase
+  context "BERT" do
+    setup do
+      time = Time.at(1254976067)
+      @ruby = t[:user, {:name => 'TPW'}, [/cat/i, 9.9], time, nil, true, false, :true, :false]
+      @bert = "\203h\td\000\004userh\003d\000\004bertd\000\004dictl\000\000\000\001h\002d\000\004namem\000\000\000\003TPWjl\000\000\000\002h\004d\000\004bertd\000\005regexm\000\000\000\003catl\000\000\000\001d\000\bcaselessjc9.900000000000000e+00\000\000\000\000\000\000\000\000\000\000jh\005d\000\004bertd\000\004timeb\000\000\004\346b\000\016\344\303a\000h\002d\000\004bertd\000\003nilh\002d\000\004bertd\000\004trueh\002d\000\004bertd\000\005falsed\000\004trued\000\005false"
+      @ebin = "<<131,104,9,100,0,4,117,115,101,114,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,4,110,97,109,101,109,0,0,0,3,84,80,87,106,108,0,0,0,2,104,4,100,0,4,98,101,114,116,100,0,5,114,101,103,101,120,109,0,0,0,3,99,97,116,108,0,0,0,1,100,0,8,99,97,115,101,108,101,115,115,106,99,57,46,57,48,48,48,48,48,48,48,48,48,48,48,48,48,48,101,43,48,48,0,0,0,0,0,0,0,0,0,0,106,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,104,2,100,0,4,98,101,114,116,100,0,3,110,105,108,104,2,100,0,4,98,101,114,116,100,0,4,116,114,117,101,104,2,100,0,4,98,101,114,116,100,0,5,102,97,108,115,101,100,0,4,116,114,117,101,100,0,5,102,97,108,115,101>>"
+    end
+
+    should "encode" do
+      assert_equal @bert, BERT.encode(@ruby)
+    end
+
+    should "decode" do
+      assert_equal @ruby, BERT.decode(@bert)
+    end
+
+    should "ebin" do
+      assert_equal @ebin, BERT.ebin(@bert)
+    end
+
+    should "do roundtrips" do
+      dd = []
+      dd << 1
+      dd << 1.0
+      dd << :a
+      dd << t[]
+      dd << t[:a]
+      dd << t[:a, :b]
+      dd << t[t[:a, 1], t[:b, 2]]
+      dd << []
+      dd << [:a]
+      dd << [:a, 1]
+      dd << [[:a, 1], [:b, 2]]
+      dd << "a"
+
+      dd << nil
+      dd << true
+      dd << false
+      dd << {}
+      dd << {:a => 1}
+      dd << {:a => 1, :b => 2}
+      dd << Time.now
+      dd << /^c(a)t$/i
+      
+      dd << 256**256 - 1
+
+      dd << :true
+      dd << :false
+      dd << :nil
+
+      dd.each do |d|
+        assert_equal d, BERT.decode(BERT.encode(d))
+      end
+    end
+
+    # should "let me inspect it" do
+    #   puts
+    #   p @ruby
+    #   ruby2 = BERT.decode(@bert)
+    #   p ruby2
+    #   bert2 = BERT.encode(ruby2)
+    #   ruby3 = BERT.decode(bert2)
+    #   p ruby3
+    # end
+  end
+end

data/test/decoder_test.rb

@@ -0,0 +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
+      assert_equal nil, BERT::Decoder.decode(BERT_NIL)
+    end
+
+    should "convert nested nil" do
+      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
+      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.decode(bert)
+    end
+
+    should "convert empty hashes" do
+      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.decode(bert)
+    end
+
+    should "convert nested hashes" do
+      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.decode(bert)
+    end
+
+    should "convert true" do
+      assert_equal true, BERT::Decoder.decode(BERT_TRUE)
+    end
+
+    should "convert false" do
+      assert_equal false, BERT::Decoder.decode(BERT_FALSE)
+    end
+
+    should "convert times" do
+      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.decode(bert)
+    end
+
+    should "convert regexen" do
+      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.decode(bert)
+    end
+
+    should "leave other stuff alone" do
+      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

@@ -0,0 +1,92 @@
+require 'test_helper'
+
+class EncoderTest < Test::Unit::TestCase
+  context "BERT Encoder complex type converter" do
+    should "convert nil" do
+      assert_equal [:bert, :nil], BERT::Encoder.convert(nil)
+    end
+
+    should "convert nested nil" do
+      before = [nil, [nil]]
+      after = [[:bert, :nil], [[:bert, :nil]]]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    should "convert hashes" do
+      before = {:foo => 'bar'}
+      after = [:bert, :dict, [[:foo, 'bar']]]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    should "convert nested hashes" do
+      before = {:foo => {:baz => 'bar'}}
+      after = [:bert, :dict, [[:foo, [:bert, :dict, [[:baz, "bar"]]]]]]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    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?(Array)
+      assert arr[2][0].is_a?(Array)
+    end
+
+    should "convert tuple to array" do
+      arr = BERT::Encoder.convert(t[:foo, 2])
+      assert arr.is_a?(Array)
+    end
+
+    should "convert array to erl list" do
+      list = BERT::Encoder.convert([1, 2])
+      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?(Array)
+    end
+
+    should "convert true" do
+      before = true
+      after = [:bert, :true]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    should "convert false" do
+      before = false
+      after = [:bert, :false]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    should "convert times" do
+      before = Time.at(1254976067)
+      after = [:bert, :time, 1254, 976067, 0]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    should "convert regexen" do
+      before = /^c(a)t$/ix
+      after = [:bert, :regex, '^c(a)t$', [:caseless, :extended]]
+      assert_equal after, BERT::Encoder.convert(before)
+    end
+
+    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?(BERT::Tuple)
+      assert cruby[0].instance_of?(Symbol)
+      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
+      before = [1, 2.0, [:foo, 'bar']]
+      assert_equal before, BERT::Encoder.convert(before)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'ext', 'bert', 'c'))
+
+load 'bert.rb'
+
+puts "Using #{BERT::Decode.impl} implementation."

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: schleyfox-bert
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 2
+  version: 1.1.2
+platform: ruby
+authors: 
+- Tom Preston-Werner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-02 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: BERT Serializiation for Ruby (1.9 Update)
+email: tom@mojombo.com
+executables: []
+
+extensions: 
+- ext/bert/c/extconf.rb
+- ext/bert/c/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.md
+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/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
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/mojombo/bert
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: BERT Serializiation for Ruby
+test_files: 
+- test/bert_test.rb
+- test/decoder_test.rb
+- test/encoder_test.rb
+- test/test_helper.rb