boss-protocol 0.0.2 → 0.1.0

data/README.md

@@ -23,10 +23,21 @@ json/boss/whatever. For example, typical JSON reduces in size twice with Boss.
 
 Boss protocol also allow to transparently compress its representations.
 
-*Attention* ruby version is under final development, its streaming support may
-not work as expected, while the rest seem to work just fine.
-
-There are versions in C and Python that are in most part ready but are parts
+Supported types:
+
+ * Signed integers of any length
+ * Signed floats and doubles (4 or 8 bytes)
+ * Boolean values (true/false)
+ * UTF-8 encoded texts, any length
+ * Binary data, any length
+ * Time objects (rounded to 1s resolution)
+ * Arrays with any number of elements
+ * Hashes with any keys and values and unlimited length
+ * Reference to the object that already was serialized
+
+There is a pending extension to serialize user types that will be available
+soon or even faster - leave me a request in issues. There are also versions
+in C and Python that are in most part ready but are parts
 in other systems and need to be extracted first.
 
 ## Installation
@@ -74,9 +85,8 @@ To use the transparent compression:
 
 ## Streaming sample
 
-Cehck the code in samples folder.
-
-This sample shows boss object passing between 2 forked processes:
+This sample shows boss object hierarchies passing between 2 forked processes
+using a pipe:
 
     if fork
       wr.close
@@ -96,15 +106,16 @@ This sample shows boss object passing between 2 forked processes:
       out << ["Foo", "bar"]
       out.put_compressed "Zz"*62
       out << ["Hello", "world", "!"]
-      out << { "Thats all" => "folks!" }
+      out << { "That's all" => "folks!" }
       wr.close
     end
 
-Boss ways in the sample are identical; second one (with get) may be sometimes
+Both ways in the sample are identical; second one (with get) may be sometimes
 more convenient, say, to terminate object polling on some condition before eof.
 
-So, all you need is IO-like object that provide io.read(length) and io.write(data) to
-read/write binary data. Usual files, pipes, tcp sockets, stringIO - everything is ok.
+All you need is IO-like object that provide io.read(length) on the read side
+and io.write(data) on another, capable to read/write binary data. Usual files,
+pipes, tcp sockets, stringIO - everything is ok.
 
 The protocol could be very effectively used to form higher level protocols over the
 network as it caches data on the fly and can provide links (if used with

data/lib/boss-protocol/version.rb

@@ -1,3 +1,3 @@
 module Boss
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/boss-protocol.rb

@@ -82,6 +82,7 @@ module Boss
   TFALSE = 13
 
   TCOMPRESSED = 14
+  TTIME = 15
 
   def checkArg(cond, msg=nil)
     raise ArgumentError unless cond
@@ -182,6 +183,9 @@ module Boss
           whdr TYPE_EXTRA, ob ? TTRUE : TFALSE
         when nil
           whdr TYPE_CREF, 0
+        when Time
+          whdr TYPE_EXTRA, TTIME
+          wrenc ob.to_i
         else
           error = "error: not supported object: #{ob}, #{ob.class}"
           p error
@@ -340,6 +344,8 @@ module Boss
                 else
                   raise UnknownTypeException, "type #{type}"
               end
+            when TTIME
+              Time.at renc
             else
               raise UnknownTypeException
           end

data/spec/boss_spec.rb

@@ -15,7 +15,7 @@ describe 'Boss' do
   end
 
   it 'should perform compatible decode' do
-    Vectors.each do |a,b|
+    Vectors.each do |a, b|
       Boss.load(a).should == b
     end
   end
@@ -36,16 +36,23 @@ describe 'Boss' do
   end
 
   it 'should properly encode nil' do
-      round_check(1)
-      round_check(nil)
-      round_check([1])
-      round_check([nil,nil,nil,3,4,5, nil])
+    round_check(1)
+    round_check(nil)
+    round_check([1])
+    round_check([nil, nil, nil, 3, 4, 5, nil])
+  end
+
+  it 'should encode Time' do
+    # Time is rounded to seconds on serialization, so we need
+    # take care of the comparison
+    t = Time.now
+    Boss.load(Boss.dump t).should be_within(1).of(t)
   end
 
   it 'should cache data' do
-    a = [1,2,3,4]
-    ca = { 1 => 55 }
-    b, c, d, e, f, g = Boss.load(Boss.dump([a,a,ca,ca, "oops", "oops"]))
+    a                = [1, 2, 3, 4]
+    ca               = { 1 => 55 }
+    b, c, d, e, f, g = Boss.load(Boss.dump([a, a, ca, ca, "oops", "oops"]))
     a.should == b
     b.should == c
     b.should be_eql(c)
@@ -65,30 +72,30 @@ describe 'Boss' do
   end
 
   it 'should decode one by one using block' do
-    args = [1,2,3,4,5]
-    s = Boss.dump(*args)
-    res = []
-    res = Boss.load(s) { |x| x }
+    args = [1, 2, 3, 4, 5]
+    s    = Boss.dump(*args)
+    res  = []
+    res  = Boss.load(s) { |x| x }
     args.should == res
   end
 
   it 'should cache arrays and hashes too' do
     d = { "Hello" => "world" }
-    a = [112,11]
-    r = Boss.load_all(Boss.dump( a,d,a,d ))
-    [a,d,a,d].should == r
+    a = [112, 11]
+    r = Boss.load_all(Boss.dump(a, d, a, d))
+    [a, d, a, d].should == r
     r[1].should be_equal(r[3])
     r[0].should be_equal(r[2])
   end
 
   it 'should properly encode multilevel structures' do
-    root = { "level" => 1}
-    p = root
+    root = { "level" => 1 }
+    p    = root
     200.times { |n|
-      x = { "level" => n+2}
-      p['data'] = x
+      x            = { "level" => n+2 }
+      p['data']    = x
       p['payload'] = 'great'
-      p = x
+      p            = x
     }
     round_check root
   end
@@ -97,13 +104,13 @@ describe 'Boss' do
   it 'should effectively compress/decompress' do
     # No compression
     data = "Too short"
-    x0 = Boss.dump_compressed data
+    x0   = Boss.dump_compressed data
     Boss.load(x0).should == data
     x0.length.should <= (data.length + 3)
 
     # short compression: zlib
     data = "z" * 1024
-    x1 = Boss.dump_compressed data
+    x1   = Boss.dump_compressed data
     Boss.load(x1).should == data
     x1.length.should <= (data.length/10)
 
@@ -131,7 +138,7 @@ describe 'Boss' do
   Vectors = [['8', 7], ["\xb8F", 70], [".\x00\x08\n8:", [0, 1, -1, 7, -7]], ["\xc8p\x11\x01", 70000],
              ['+Hello', 'Hello'], [',Hello', bytes!('Hello'), 2, 4, 4, 1]]
 
-  CompressedTestJson =  <<-End
+  CompressedTestJson = <<-End
 eJztfVlz20iy7vv5FQi9dHcExca++OWGLLvdXmTrWOrxmbm+MVEkimRZIMDG
 Ipk+0f/9ZmZVAQVQpETKmhhPaKKn3ZaIIlCV+SGXLzP/978s+N/RktfsyHpm
 /e9RVbO6qY6eHRVXR3+N5G9LXq2KvOLyE6LmS/jA/4X/So+e+bEzOsrZksMl
@@ -462,6 +469,6 @@ mizfqNHM4GxlFv0UHm8hpGOGRQjy2UGa17xW1dcpFlyBMPF0PL5HbDcJfHsz
 GOPFwUaiO8beVd7QYfG/2yg0t2XZnuHHyrU8/A4qXN/xDugS4Wqi7R3L/rgI
 ZPRlks8o0Gc+RzbVHfjjBc+8ffGnPSaQaU6ZDxOCIu82CDqxTouy6UhoFPN1
 NhpXhYHtuZti57hJEhySiPp/f/3XX//1/wEcUSZF
-End
+  End
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boss-protocol
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors: