codec 0.0.12 → 1.0.0

data/lib/codec/version.rb

@@ -1,3 +1,3 @@
 module Codec
-  VERSION = "0.0.12"
+  VERSION = "1.0.0"
 end

data/test/lib/codec/bitmap_test.rb

@@ -2,43 +2,45 @@ require_relative '../../test_helper'
  
 describe Codec::Bitmap do
   
-  subject { Codec::Bitmap.new('Bitmap',2) }
+  subject { Codec::Bitmap.new(2) }
   
   before do
-    subject.add_sub_codec('1',Codec::Numasc.new('*',3))
-    subject.add_sub_codec('2', Codec::String.new('*',5))
-    subject.add_sub_codec('3', Codec::String.new('*',3))
-    subject.add_sub_codec('15', Codec::Numbin.new('*',2))
+    subject.add_sub_codec('1',Codec::Numasc.new(3))
+    subject.add_sub_codec('2', Codec::String.new(5))
+    subject.add_sub_codec('3', Codec::String.new(3))
+    subject.add_sub_codec('15', Codec::Numbin.new(2))
     @buffer = ["1100000000000010","012ABCDE","0012"].pack("B*A*H*")
     @field = Codec::Field.from_array('Bitmap',[['1',12],['2','ABCDE'],['15',18]])
   end
 
-  it "must be a BaseComposed codec" do
+  it "must be a Bitmap codec" do
     subject.must_be_instance_of(Codec::Bitmap)
   end
   
   it "must generate composed field from buffer" do
-    subject.decode(@buffer).first.must_equal(@field)
+    f = Codec::Field.new('Bitmap')
+    subject.decode(@buffer, f)
+    f.must_equal(@field)
   end
 
 end
 
 describe Codec::Bitmap do
   
-  subject { Codec::Bitmap.new('MultipleBitmap',2) }
+  subject { Codec::Bitmap.new(2) }
   
   before do
     subject.add_extended_bitmap('1')
-    subject.add_sub_codec('2',Codec::Numasc.new('*',3))
-    subject.add_sub_codec('3', Codec::String.new('*',5))
-    subject.add_sub_codec('4', Codec::String.new('*',3))
-    subject.add_sub_codec('18', Codec::Numbin.new('*',2))
-    subject.add_sub_codec('21', Codec::String.new('*',5))
+    subject.add_sub_codec('2',Codec::Numasc.new(3))
+    subject.add_sub_codec('3', Codec::String.new(5))
+    subject.add_sub_codec('4', Codec::String.new(3))
+    subject.add_sub_codec('18', Codec::Numbin.new(2))
+    subject.add_sub_codec('21', Codec::String.new(5))
     @buffer_1 = ["11000000000000000100100000000000","012","0012","ABCDE"].pack("B*A*H*A*")
     @buffer_2 = ["0110000000000000","012","ABCDE"].pack("B*A3A5")
-    @field_1 = Codec::Field.from_array('MultipleBitmap',[['2',12],['18',18],['21',"ABCDE"]])
-    @field_2 = Codec::Field.from_array('MultipleBitmap',[['2',12],['3','ABCDE']])
-    @field_3 = Codec::Field.from_array('MultipleBitmap',[['2',12],['41',18],['21',"ABCDE"]])
+    @field_1 = Codec::Field.from_array('test1',[['2',12],['18',18],['21',"ABCDE"]])
+    @field_2 = Codec::Field.from_array('test2',[['2',12],['3','ABCDE']])
+    @field_3 = Codec::Field.from_array('test3',[['2',12],['41',18],['21',"ABCDE"]])
   end
 
   it "must be a Bitmap codec" do
@@ -46,19 +48,26 @@ describe Codec::Bitmap do
   end
   
   it "must generate composed field from buffer with extended bitmap" do
-    subject.decode(@buffer_1).first.must_equal(@field_1)
+    f1 = Codec::Field.new('test1')
+    subject.decode(@buffer_1,f1)
+    f1.must_equal(@field_1)
   end
 
   it "must generate composed field from buffer without extended bitmap" do
-    subject.decode(@buffer_2).first.must_equal(@field_2)
+    f2 = Codec::Field.new('test2')
+    subject.decode(@buffer_2,f2)
+    f2.must_equal(@field_2)
   end
   
   it "must generate buffer from composed field" do
-    subject.encode(@field_1).must_equal(@buffer_1)
+    buf1 = ""
+    subject.encode(buf1, @field_1)
+    buf1.unpack("H*").first.must_equal(@buffer_1.unpack("H*").first)
   end
 
   it "must raise Encoding exception if subfield is unknown" do
-    proc { subject.encode(@field_3) }.must_raise(Codec::EncodingException)
+    buf = ""
+    proc { subject.encode(buf, @field_3) }.must_raise(Codec::EncodingException)
   end  
   
 end

data/test/lib/codec/composed_test.rb

@@ -1,13 +1,13 @@
 require_relative '../../test_helper'
  
 describe Codec::BaseComposed do
-  subject { Codec::BaseComposed.new('BaseComposed') }
+  subject { Codec::BaseComposed.new }
 
   before do
-    subject.add_sub_codec('CHP1', Codec::Numasc.new('CHP1',3))
-    subject.add_sub_codec('CHP2', Codec::String.new('CHP2',5))
-    subject.add_sub_codec('CHP3', Codec::String.new('CHP3',4))
-    subject.add_sub_codec('CHP4', Codec::Numasc.new('CH4',4))
+    subject.add_sub_codec('CHP1', Codec::Numasc.new(3))
+    subject.add_sub_codec('CHP2', Codec::String.new(5))
+    subject.add_sub_codec('CHP3', Codec::String.new(4))
+    subject.add_sub_codec('CHP4', Codec::Numasc.new(4))
     field_array = [['CHP1',12],['CHP2','ABCDE'],['CHP3','WXYZ'],['CHP4',23]]
     @buffer_test1 = "012ABCDEWXYZ0023"
     @field_test1 = Codec::Field.from_array('BaseComposed', field_array)
@@ -20,29 +20,38 @@ describe Codec::BaseComposed do
   end
   
   it "must generate a field with computed value" do
-    subject.decode(@buffer_test1).first.must_equal(@field_test1)
+    f1 = Codec::Field.new("BaseComposed")
+    subject.decode(@buffer_test1,f1)
+    f1.must_equal(@field_test1)
   end
 
   it "must encode buffer with composed field" do
-    subject.encode(@field_test1).must_equal(@buffer_test1)
+    buf1 = ""
+    subject.encode(buf1, @field_test1)
+    buf1.must_equal(@buffer_test1)
   end
   
   it "must encode buffer with composed field without codec's last field " do
-    subject.encode(@field_test2).must_equal(@buffer_test2)
+    buf = ""
+    subject.encode(buf, @field_test2)
+    buf.must_equal(@buffer_test2)
   end  
   
   it "must handle remaining data" do
-    subject.decode("012ABCDEWXYZ0023123").last.must_equal("123")
+    buf = "012ABCDEWXYZ0023123"
+    f = Codec::Field.new
+    subject.decode(buf,f)
+    buf.must_equal("123")
   end
 end
 
-describe Codec::CompleteComposed do
-  subject { Codec::CompleteComposed.new('CompleteComposed') }
+describe Codec::BaseComposed do
+  subject { Codec::BaseComposed.new(true) }
 
   before do
-    test_1 = [['CHP1',Codec::Numasc.new('*',3),12],
-      ['CHP2',Codec::String.new('*',5),"ABCDE"],
-      ['CHP3',Codec::String.new('*',4),"WXYZ"]]
+    test_1 = [['CHP1',Codec::Numasc.new(3),12],
+      ['CHP2',Codec::String.new(5),"ABCDE"],
+      ['CHP3',Codec::String.new(4),"WXYZ"]]
     field_array = test_1.collect{|id,codec,value| [id,value]}
     @field_1 = Codec::Field.from_array('CompleteComposed',field_array)
     test_1.each { |id,codec,value| subject.add_sub_codec(id,codec) }
@@ -51,29 +60,34 @@ describe Codec::CompleteComposed do
     @buffer_3 = "012ABCDE"
     @field_2 = Codec::Field.from_array('CompleteComposed',field_array[0,2])
   end
- 
-  it "must be a CompleteComposed codec" do
-    subject.must_be_instance_of(Codec::CompleteComposed)
-  end
   
   it "must generate a field with computed value" do
-    subject.decode(@buffer_1).first.must_equal(@field_1)
+    f = Codec::Field.new("CompleteComposed")
+    subject.decode(@buffer_1,f)
+    f.must_equal(@field_1)
   end
   
   it "must handle remaining data" do
-    subject.decode(@buffer_1).last.must_equal("123")
+    buf = @buffer_1
+    f = Codec::Field.new("CompleteComposed")
+    subject.decode(buf, f)
+    buf.must_equal("123")
   end
  
   it "must raise BufferUnderflow if missing field" do
-    proc { subject.decode(@buffer_3)}.must_raise(Codec::BufferUnderflow)
+    f = Codec::Field.new("CompleteComposed")
+    proc { subject.decode(@buffer_3,f) }.must_raise(Codec::BufferUnderflow)
   end
   
   it "must encode expected buffer" do
-    subject.encode(@field_1).must_equal(@buffer_2)
+    buf = ""
+    subject.encode(buf, @field_1)
+    buf.must_equal(@buffer_2)
   end 
 
   it "must raise EncodingException if missing field" do
-    proc { subject.encode(@field_2)}.must_raise(Codec::EncodingException)
+    buf = ""
+    proc { subject.encode(buf, @field_2)}.must_raise(Codec::EncodingException)
   end
 
 end

data/test/lib/codec/eightbits_test.rb

@@ -3,36 +3,40 @@ require_relative '../../test_helper'
  
 describe Codec::Ascii do
 
-  subject { Codec::Ascii.new('test',3) }
-  
-  it "must be a Codec::Ascii" do
-    subject.must_be_instance_of(Codec::Ascii)
-  end
+  subject { Codec::Ascii.new(3) }
   
   it "must encode field from utf-8 to ascii" do
-    subject.encode(Codec::Field.new('test','été')).must_equal(["827482"].pack("H*"))
+    f = Codec::Field.new('test','été')
+    buff =""
+    subject.encode(buff, f)
+    buff.must_equal(["827482"].pack("H*"))
   end
 
   it "must decode from ascii stream to utf-8 field" do
-    subject.decode(["827482"].pack("H*")).first.must_equal(Codec::Field.new('test','été'))
+    buff = ["827482"].pack("H*")
+    f = Codec::Field.new('test')
+    subject.decode(buff,f)
+    f.must_equal(Codec::Field.new('test','été'))
   end
 
 end
 
 describe Codec::Ebcdic do
 
-  subject { Codec::Ebcdic.new('test',3) }
-  
-  it "must be a Codec::Ebcdic" do
-    subject.must_be_instance_of(Codec::Ebcdic)
-  end
+  subject { Codec::Ebcdic.new(3) }
   
   it "must encode field from utf-8 to Ebcdic" do
-    subject.encode(Codec::Field.new('test','été')).must_equal(["85A385"].pack("H*"))
+    f = Codec::Field.new('test','été')
+    buff =""
+    subject.encode(buff, f)
+    buff.must_equal(["85A385"].pack("H*"))
   end
 
   it "must decode from Ebcdic stream to utf-8 field" do
-    subject.decode(["85A385"].pack("H*")).first.must_equal(Codec::Field.new('test','ete'))
+    buff = ["85A385"].pack("H*")
+    f = Codec::Field.new('test')
+    subject.decode(buff, f)
+    f.must_equal(Codec::Field.new('test','ete'))
   end
 
 end

data/test/lib/codec/fix_test.rb

@@ -1,7 +1,7 @@
 require_relative '../../test_helper'
  
 describe Codec::Numbin do
-  subject { Codec::Numbin.new('Test',4) }
+  subject { Codec::Numbin.new(4) }
 
   before do
     @f256 = Codec::Field.new
@@ -13,89 +13,101 @@ describe Codec::Numbin do
   end
   
   it "must generate a field with computed value" do
-    subject.decode(["00000100"].pack("H*")).first.get_value.to_i.must_equal(256)
+    f = Codec::Field.new
+    subject.decode(["00000100"].pack("H*"),f)
+    f.get_value.to_i.must_equal(256)
   end
   
-  it "must generate a field with computed value" do
-    subject.decode(["00000100"].pack("H*")).last.size.must_equal(0)
+  it "remaining buffer must be empty" do
+    f = Codec::Field.new
+    buf = ["00000100"].pack("H*")
+    subject.decode(buf,f)
+    buf.must_be_empty
   end
 
   it "must generate a field with computed value" do
-    subject.encode(@f256).must_equal(["00000100"].pack("H*"))
+    buf = ""
+    subject.encode(buf, @f256)
+    buf.must_equal(["00000100"].pack("H*"))
   end
 end
 
 describe Codec::Numasc do
-  subject { Codec::Numasc.new('Test',4) }
+  subject { Codec::Numasc.new(4) }
   
   before do
     @f12 = Codec::Field.new
     @f12.set_value(12)
   end
   
-  it "must be a codec" do
-    subject.must_be_instance_of(Codec::Numasc)
-  end
-  
   it "must generate a field with computed value" do
-    subject.decode("0012").first.get_value.to_i.must_equal(12)
+    f = Codec::Field.new
+    subject.decode("0012",f)
+    f.get_value.must_equal(12)
   end
   
-  it "must generate a field with computed value" do
-    subject.decode("0012").last.size.must_equal(0)
+  it "remaining buffer must be empty" do
+    buf = "0012"
+    f = Codec::Field.new
+    subject.decode(buf,f)
+    buf.must_be_empty
   end
 
   it "must generate a field with computed value" do
-    subject.encode(@f12).must_equal("0012")
+    buf = ""
+    subject.encode(buf, @f12)
+    buf.must_equal("0012")
   end
 end
 
 describe Codec::String do
-  subject { Codec::String.new('Test',10) }
-  before do
-    @fstring = Codec::Field.new
-    @fstring.set_value("TEST")
-  end
-  
-  it "must be a codec" do
-    subject.must_be_instance_of(Codec::String)
-  end
+  subject { Codec::String.new(10) }
   
   it "must generate a field with computed value" do
-    subject.decode("Testing string").first.get_value.must_equal("Testing st")
+    f = Codec::Field.new
+    subject.decode("Testing string",f)
+    f.get_value.must_equal("Testing st")
   end
   
   it "must also return remaining data" do
-    subject.decode("Testing string").last.must_equal("ring")
+    buf = "Testing string"
+    f = Codec::Field.new
+    subject.decode(buf, f)
+    buf.must_equal("ring")
   end
 
   it "must generate a buffer with corresponding value padded with space" do
-    subject.encode(@fstring).must_equal("TEST      ")
+    f = Codec::Field.new
+    f.set_value("TEST")
+    buf = ""
+    subject.encode(buf, f)
+    buf.must_equal("TEST      ")
   end
 end
 
 describe Codec::Binary do
-  subject { Codec::Binary.new('Test',8) }
+  subject { Codec::Binary.new(8) }
   before do
     @unpack_buffer = "ABCDEF0123456789"
     @bin_buffer = [@unpack_buffer].pack("H*")
+    @computed_f = Codec::Field.new
     @fbin = Codec::Field.new
     @fbin.set_value(@unpack_buffer)
   end
   
-  it "must be a codec" do
-    subject.must_be_instance_of(Codec::Binary)
-  end
-  
   it "must generate a field with computed value" do
-    subject.decode(@bin_buffer).first.get_value.must_equal(@unpack_buffer)
+    subject.decode(@bin_buffer,@computed_f)
+    @computed_f.get_value.must_equal(@unpack_buffer)
   end
   
-  it "must return no remaining data" do
-    subject.decode(@bin_buffer).last.must_equal("")
+  it "remaining buffer must be empty" do
+    subject.decode(@bin_buffer,@computed_f)
+    @bin_buffer.must_be_empty
   end
 
   it "must regenerate corresponding buffer" do
-    subject.encode(@fbin).must_equal(@bin_buffer)
+    buf = ""
+    subject.encode(buf, @fbin)
+    buf.must_equal(@bin_buffer)
   end
 end

data/test/lib/codec/pckd_test.rb

@@ -1,71 +1,67 @@
 require_relative '../../test_helper'
  
-describe Codec::Packed do
-  subject { Codec::Packed.new('Test',6) }
+# No more required encode return the field length for upper codec layer
+# describe Codec::Packed do
+#   subject { Codec::Packed.new(6) }
+# 
+#   it "must retrieve field length" do
+#     f_pck = Codec::Field.new
+#     f_pck.set_value(123)  
+#     subject.get_length(@f_pck).must_equal(6)
+#   end
+# 
+# end
 
-  before do
-    @f_pck = Codec::Field.new
-    @f_pck.set_value("123")
-  end
-  
-  it "must be a codec" do
-    subject.must_be_instance_of(Codec::Packed)
-  end
-  
-  it "must retrieve field length" do
-    subject.get_length(@f_pck).must_equal(6)
-  end
-
-end
-
-describe Codec::Numpck do
-  subject { Codec::Numpck.new('Test',5) }
+describe "Numeric packed" do
+  subject { Codec::Packed.new(5) }
   
   before do
     @f12 = Codec::Field.new
     @f12.set_value(12)
+    @f = Codec::Field.new
     @pck_buff = ["000012"].pack("H*")
   end
   
-  it "must be a codec" do
-    subject.must_be_instance_of(Codec::Numpck)
-  end
-  
   it "must generate a field with computed value" do
-    subject.decode(@pck_buff).first.get_value.to_i.must_equal(12)
+    subject.decode(@pck_buff,@f)
+    @f.get_value.must_equal(12)
   end
   
-  it "must not remain data" do
-    subject.decode(@pck_buff).last.size.must_equal(0)
+  it "remaining buffer must be empty" do
+    subject.decode(@pck_buff,@f)
+    @pck_buff.must_be_empty
   end
 
   it "must generate a field with computed value" do
-    subject.encode(@f12).must_equal(@pck_buff)
+    buf=""
+    subject.encode(buf, @f12)
+    buf.must_equal(@pck_buff)
   end
 end
 
-describe Codec::Strpck do
-  subject { Codec::Strpck.new('Test',11) }
+describe "Packed rigth padded with F" do
+  subject { Codec::Packed.new(11,false,true,true) }
   before do
     @unpack_buffer = "497011D9010"
     @bin_buffer = [@unpack_buffer + "F"].pack("H*")
     @fbin = Codec::Field.new
     @fbin.set_value(@unpack_buffer)
-  end
-  
-  it "must be a codec" do
-    subject.must_be_instance_of(Codec::Strpck)
+    @f = Codec::Field.new
   end
   
   it "must generate a field with computed value" do
-    subject.decode(@bin_buffer).first.get_value.upcase.must_equal(@unpack_buffer)
+    subject.decode(@bin_buffer,@f)
+    @f.get_value.upcase.must_equal(@unpack_buffer)
   end
   
-  it "must return no remaining data" do
-    subject.decode(@bin_buffer).last.must_equal("")
+  it "remaining buffer must be empty" do
+    subject.decode(@bin_buffer,@f)
+    @bin_buffer.must_be_empty
   end
 
   it "must regenerate corresponding buffer" do
-    subject.encode(@fbin).must_equal(@bin_buffer)
+    buf = ""
+    subject.encode(buf, @fbin)
+    buf.must_equal(@bin_buffer)
   end
 end