codec 0.0.12 → 1.0.0

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+rake_test.log

data/Rakefile

@@ -3,6 +3,12 @@ require "bundler/gem_tasks"
  
 require 'rake/testtask'
  
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r codec.rb"
+end
+ 
+ 
 Rake::TestTask.new do |t|
   t.libs << 'lib/codec'
   t.test_files = FileList['test/lib/codec/*_test.rb']

data/codec.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.name          = "codec"
   spec.require_paths = ["lib"]
   spec.version       = Codec::VERSION
+  spec.add_dependency "log4r"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "log4r"
 end

data/lib/codec.rb

@@ -14,4 +14,12 @@ require 'codec/tlv'
 
 module Codec
   # TODO : here implements Module constants and methods
+  
+  # method use to log deprecation warning
+  def self.deprecated(msg)
+    stack = Kernel.caller
+    stack.shift
+    Logger.warn "DEPRECATED: #{msg} | Call stack :
+    #{stack.select{|l| l =~ /codec\/lib/}.each{|l| l}.join("\n")}"
+  end
 end

data/lib/codec/base.rb

@@ -1,59 +1,20 @@
 module Codec
   class Base
-    attr_reader :id
-    def initialize(id,length)
-        @length = length.to_i
-        @id = id
-    end
-
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(buf[0,length])
-      return f
-    end
     
-    def decode_with_length(buf,length)
-      l = eval_length(buf,length)
-      return build_field(buf,l),buf[l,buf.length]
-    end
-    
-    def decode(buf)
-      l = eval_length(buf,@length)
-      return build_field(buf,l),buf[l,buf.length]
+    def decode(buf,field)
+      raise "Abstract Codec"
     end    
 
-    def encode(field)
-      return field.get_value
-    end
-    
-    def encode_with_length(field)
-      buf = encode(field)
-      return buf.length, buf
-    end
-    
-    def get_length(field)
-      field.get_value.length
+    def encode(buf,field)
+      raise "Abstract Codec"
     end
 
-    def eval_length(buf,length)
-	    length = 0 if length.nil?
-      if(length != 0)
-	      if buf.length < length
-	        raise BufferUnderflow, "Not enough data for parsing #{@id} (#{length}/#{buf.length})"
-	      end
-        return length
-      else
-        return buf.length
-      end
-    end
-    
-    def add_sub_codec(id_field,codec)
+    def add_sub_codec(field_id,codec)
 	    if codec.nil?
-	      raise InitializeException, "Invalid codec reference in subcodec #{id_field} for codec #{@id}"
+	      raise InitializeException, "Invalid codec reference in subcodec #{field_id} for codec #{@id}"
 	    end
-      if @subCodecs.kind_of? Hash
-        @subCodecs[id_field] = codec 
-      end
+      @subCodecs ||= {}
+      @subCodecs[field_id] = codec 
     end 
 	
 	  def get_sub_codecs

data/lib/codec/bitmap.rb

@@ -1,8 +1,8 @@
 module Codec
   class Bitmap < Base
     NB_BITS_BY_BYTE = 8
-    def initialize(id,length)
-      super(id,length)
+    def initialize(length)
+      @length=length
       @num_extended_bitmaps=[]
       @subCodecs = {}
     end
@@ -10,71 +10,78 @@ module Codec
     def bitmap_length
       @length * NB_BITS_BY_BYTE
     end
+    
     def add_extended_bitmap(num_extention)
       @num_extended_bitmaps << num_extention.to_i
     end
     
-    def decodeBitmap(buffer,first_field_num)
-      fieldsList = []
-      
-      bitmapBuffer = buffer[0,@length].unpack("B*").first
-      buf = buffer[@length,buffer.length]
+    def decode_bitmap(buffer,first_field_num)
+      fields_ids = []
+      bitmap = buffer.slice!(0...@length).unpack("B*").first
       field_num = first_field_num
-      while(bitmapBuffer.length > 0)
-        fieldsList << field_num if bitmapBuffer.start_with?('1')
-        bitmapBuffer.slice!(0)
+      until(bitmap.empty?)
+        fields_ids << field_num if bitmap.slice!(0) == "1"
         field_num += 1
       end
-      return fieldsList, buf
+      return fields_ids
     end
     
-    def encode_bitmap(fields_list,bitmap_index)
-      offset = bitmap_index * bitmap_length
+    def encode_bitmap(buf,fields_list,bitmap_index)
+      offset_id = bitmap_index * bitmap_length + 1
       bitmap = ""
-      ((offset + 1)..(offset + bitmap_length)).each do |i|
+      (offset_id...(offset_id + bitmap_length)).each do |i|
         if fields_list.include?(i)
-          bitmap += "1"
+          bitmap << "1"
         else
-          bitmap += "0"
+          bitmap << "0"
         end
       end
-      return [bitmap].pack("B*")
+      Logger.debug { "Encoding bitmap #{bitmap_index} 
+        form #{offset_id} to #{offset_id + bitmap_length - 1} 
+        with #{fields_list.collect{|id| id.to_s}.join(',')}
+        result #{bitmap}" }
+      buf << [bitmap].pack("B*")
     end
     
-    def encode(field)
+    def encode(buf, field)
+      Logger.debug { "Start bitmap encoding\n" }
+      initial_length = buf.length
       fields = field.get_value 
       encoded_fields = []
       fields_list = fields.collect{|sf| sf.get_id.to_i}
-      # Add field for bitmaps
-      bitmap_fields = @num_extended_bitmaps[0,(fields_list.last - 1) / bitmap_length]
-      fields_list +=  bitmap_fields
-      fields += bitmap_fields.collect {|id| Field.new(id)}
+      fields_list.sort!
+      nb_additionnal_bitmaps = (fields_list.last - 1) / bitmap_length
+      @num_extended_bitmaps[0...nb_additionnal_bitmaps].each{ |bitmap_field_id|
+        Logger.debug{"adding bitmap = #{bitmap_field_id}\n"}
+        fields_list << bitmap_field_id
+        fields << Field.new(bitmap_field_id)
+      }
       fields.sort!{|a,b| a.get_id.to_i <=> b.get_id.to_i}
       # Encode first bitmap
-      out = encode_bitmap(fields_list,0)
-      bitmap_index = 1
+      bitmap_itt = 0
+      encode_bitmap(buf,fields_list,bitmap_itt)
       fields.each do |sf|
         codec = @subCodecs[sf.get_id]
         if @num_extended_bitmaps.include?(sf.get_id)
-          out += encode_bitmap(fields_list,bitmap_index)
-          bitmap_index += 1
+          bitmap_itt += 1
+          encode_bitmap(buf, fields_list, bitmap_itt)
         elsif codec.nil?
           raise EncodingException, "unknown codec for subfield #{sf.get_id}"
         elsif encoded_fields.include?(sf.get_id.to_i)
           raise EncodingException, "Multiple subfield #{sf.get_id} is invalid for Codec::Bitmap"
         else
-          out += codec.encode(sf)
+          codec.encode(buf,sf)
         end
         encoded_fields << sf.get_id.to_i
       end
-      return out
+      return buf.length - initial_length      
     end
-    
-    def decode(buffer)
-      msg = Field.new(@id)
+
+    def decode(buf,msg, length=nil)
+      buf = buf.slice!(0...length) if length && length > 0
       field_num = 1
       # 1. read bitmap
-      fields_list,buf = decodeBitmap(buffer,field_num)
+      fields_list = decode_bitmap(buf,field_num)
       field_num += bitmap_length
       # 2. decode each field present
       while fields_list.length > 0
@@ -82,12 +89,12 @@ module Codec
         field_id = fields_list.slice!(0)
         field_tag = field_id.to_s
         if @num_extended_bitmaps.include?(field_id)
-          nextFields,buf = decodeBitmap(buf,field_num)
+          nextFields = decode_bitmap(buf,field_num)
           fields_list = fields_list + nextFields
         elsif @subCodecs[field_tag].respond_to?(:decode)
           Logger.debug "Parsing bitmap field #{field_tag}"
-          f,buf = @subCodecs[field_tag].decode(buf)
-          f.set_id(field_tag)
+          f = Field.new(field_tag)
+          @subCodecs[field_tag].decode(buf,f)
           msg.add_sub_field(f)
         else
   	      f = Field.new("ERR") 
@@ -96,7 +103,6 @@ module Codec
           raise ParsingException.new "#{msg}\nError unknown field #{field_tag} : "
         end
       end
-      return msg,buf
     end
   end
 end

data/lib/codec/composed.rb

@@ -1,84 +1,57 @@
 module Codec
   class BaseComposed < Base
-    def initialize(id)
-      @id = id
-      @subCodecs = []
+    def initialize(isComplete = false)
+      @is_complete = isComplete
+      @subCodecs = {}
     end
     
-    def decode(buf)
-      return build_each_field(buf,buf.length)
-    end
-    
-    def encode(field)
-      return "" if field.empty?
-      subfields = field.get_value
-      composed_encoder = subfields.zip(@subCodecs).collect {|sf,sc|
-        if sf.get_id != sc.first
-          raise EncodingException, "subfield #{sf.first} not correspond to subcodec #{sc.first}"
-        end
-        [sc.last,sf]
-      } 
-      out = ""
-      composed_encoder.each do |subcodec,subfield|
-        out += subcodec.encode(subfield)
+    def decode(buf,msg, length = nil)
+      unless length.nil?
+        Logger.debug {"build composed for [#{buf.unpack("H*").first}] on #{length} bytes for #{msg.get_id} field"}
+        buf = buf.slice!(0...length)
       end
-      return out
-    end
-    
-    def build_each_field(buf,length)
-      msg = Field.new(@id)
-      working_buf = buf[0,length]
+      
       @subCodecs.each{|id,codec|
-        Logger.debug "Parsing struct field #{@id} : #{id}"
-  	    if working_buf.length == 0
-          Logger.debug "Not enough data to decode #{@id} : #{id}"
+        Logger.debug "Parsing struct field #{msg.get_id} - #{id} with [#{buf.unpack("H*").first}]"
+  	    if buf.empty?
+          Logger.debug "Not enough data to decode #{msg.get_id} : #{id}"
         else
-          f,working_buf = codec.decode(working_buf)
-          f.set_id(id)
+          f = Field.new(id)
+          codec.decode(buf,f)
           msg.add_sub_field(f)
 	      end
       }
-      return msg,working_buf
-    end
-    
-    def build_field(buf,length)
-      msg,working_buf = build_each_field(buf,length)
-      
-      if working_buf.length > 0
-        if @length_unknown 
-  	      @remain = working_buf 
-  	    else
-          f = Field.new("PADDING")
-  	      f.set_value(working_buf.unpack("H*").first)
-  	      msg.add_sub_field(f)
-  	    end
+      unless buf.empty? || length.nil?
+        f = Field.new("PADDING")
+        f.set_value(buf.unpack("H*").first)
+        msg.add_sub_field(f)
       end
-      return msg
-    end
-  
-    def add_sub_codec(id_field,codec)
-      if codec.nil?
-        raise InitializeException, "Invalid codec reference in subcodec #{id_field} for codec #{@id}"
-      end
-      @subCodecs << [id_field, codec]
-    end 
-  end
-  
-  class CompleteComposed < BaseComposed
-    def build_each_field(buf,length)
-      f,r = super(buf,length)
+      
       # Check if all struct's fields have been parsed
-      if f.get_value.size < @subCodecs.size 
-        raise BufferUnderflow, "Not enough data for parsing Struct #{@id}" 
-      end
-      return f,r
+      if @is_complete && msg.get_value.size < @subCodecs.size 
+        raise BufferUnderflow, "Not enough data for parsing Struct #{msg.get_id}" 
+      end      
     end
     
-    def encode(field)
-      if @subCodecs.size != field.get_value.size
-        raise EncodingException, "Not enough subfields to encode #{@id}"
+    def encode(buf, field)
+
+      if @is_complete && @subCodecs.size != field.get_value.size
+        raise EncodingException, "Not enough subfields to encode #{field.get_id}"
+      end
+      
+      return if field.empty?
+      initial_length = buf.length
+      subfields = field.get_value
+      composed_encoder = subfields.zip(@subCodecs).collect {|sf,sc|
+        if sf.get_id != sc.first
+          raise EncodingException, "subfield #{sf.first} not correspond to subcodec #{sc.first}"
+        end
+        [sc.last,sf]
+      } 
+      composed_encoder.each do |subcodec,subfield|
+        subcodec.encode(buf,subfield)
       end
-      super(field)
+      return buf.length - initial_length
     end
   end
 end

data/lib/codec/field.rb

@@ -63,7 +63,7 @@ module Codec
     
     def add_sub_field(sf)
       @value = [] if @value == ""
-	    raise "Add impossible on not Array valued field" unless @value.kind_of? Array
+	    raise "Add sub field impossible on #{@value.class} value class" unless @value.kind_of? Array
 	    @value << [sf.id,sf.value]
     end
     

data/lib/codec/fix.rb

@@ -1,21 +1,48 @@
 module Codec
-  
-  class Numbin < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
+  class Fix < Base
+    
+    def initialize(length=nil)
+      @length = length || 0
+    end
+    
+    def check_length(buf,length)
+	    raise "Length is nil" if length.nil?
+      if(length != 0)
+	      if buf.length < length
+	        raise BufferUnderflow, "Not enough data for decoding (#{length}/#{buf.length})"
+	      end
+        return length
+      else
+        return buf.length
+      end    
+    end
+    
+    def decode(buf,field,length=nil)
+      length ||= @length
+      l = check_length(buf,length)
+      wbuf = buf.slice!(0...l)
+      build_field(wbuf,field,l)    
+    end
+    
+    def build_field(w,f,l)
+      raise "Abstract Codec : build field not defined for #{self.class.name}"
+    end
+  end
+  class Numbin < Fix
+    def build_field(buf,f,length)
       res = 0
-      buf[0,length].unpack("C*").each{ |ubyte|
+      buf.slice!(0...length).unpack("C*").each{ |ubyte|
         res *= 256
         res += ubyte
       }
       f.set_value(res)
-      return f
     end
     
-    def encode(field)
+    def encode(buf, field)
       val = field.get_value.to_i
       out = Numbin.numbin(val,@length)
-      return out
+      buf << out
+      return out.length
     end
     
     def self.numbin(number,maxlength)
@@ -37,20 +64,19 @@ module Codec
     end
   end
 
-  class Numstr < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(buf[0,length].to_i)
-      return f
+  class Numstr < Fix
+    def build_field(buf, f, length)
+      f.set_value(buf.slice!(0...length).to_i)
     end
     
-    def encode(field)
+    def encode(buf,field)
       out = field.get_value.to_s
       if @length > 0
         out = out.rjust(@length,"0")
         raise TooLongDataException if out.length > @length
       end
-      return out
+      buf << out
+      return out.length
     end
   end
 
@@ -59,90 +85,85 @@ module Codec
     # have the same encoding for digits number
   end
   
-  class Numebc < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(EightBitsEncoding::EBCDIC_2_UTF8(buf[0,length]).to_i)
-      return f
+  class Numebc < Fix
+    def build_field(buf,f,length)
+      f.set_value(EightBitsEncoding::EBCDIC_2_UTF8(buf.slice!(0...length)).to_i)
     end
     
-    def encode(field)
+    def encode(buf, field)
       out = field.get_value.to_s
       if @length > 0
         out = out.rjust(@length,"0")
         raise TooLongDataException if out.length > @length
       end
-      return EightBitsEncoding::UTF8_2_EBCDIC(out)
+      buf << EightBitsEncoding::UTF8_2_EBCDIC(out)
+      return out.length      
     end
     
   end
   
-  class Ebcdic < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(EightBitsEncoding::EBCDIC_2_UTF8(buf[0,length]))
-      return f
+  class Ebcdic < Fix
+    def build_field(buf, f, length)
+      f.set_value(EightBitsEncoding::EBCDIC_2_UTF8(buf.slice!(0...length)))
     end
     
-    def encode(f)
+    def encode(buf, f)
       out = f.get_value
       if @length >  0
         raise TooLongDataException if out.length > @length
         out = out.ljust(@length," ")
       end
-      return EightBitsEncoding::UTF8_2_EBCDIC(out)
+      buf << EightBitsEncoding::UTF8_2_EBCDIC(out)
+      return out.length      
     end  
   end
   
-  class Ascii < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(EightBitsEncoding::ASCII_2_UTF8(buf[0,length]))
-      return f
+  class Ascii < Fix
+    def build_field(buf, f, length)
+      f.set_value(EightBitsEncoding::ASCII_2_UTF8(buf.slice!(0...length)))
     end
     
-    def encode(f)
+    def encode(buf, f)
       out = f.get_value
       if @length >  0
         raise TooLongDataException if out.length > @length
         out = out.ljust(@length," ")
       end
-      return EightBitsEncoding::UTF8_2_ASCII(out)
+      buf << EightBitsEncoding::UTF8_2_ASCII(out)
+      return out.length      
     end    
   end
   
   
-  class String < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(buf[0,length])
-      return f
+  class String < Fix
+    def build_field(buf, f, length)
+      f.set_value(buf.slice!(0...length))
     end
     
-    def encode(f)
+    def encode(buf, f)
       out = f.get_value
       if @length >  0
         raise TooLongDataException if out.length > @length
         out = out.ljust(@length," ")
       end
-      return out
+      buf << out
+      return out.length
     end    
   end
 
-  class Binary < Base
-    def build_field(buf,length)
-      f = Field.new(@id)
-      f.set_value(buf[0,length].unpack("H*").first.upcase)
-      return f
+  class Binary < Fix
+    def build_field(buf, field, length)
+      field.set_value(buf.slice!(0...length).unpack("H*").first.upcase)
     end
     
-    def encode(f)
+    def encode(buf, f)
       out = [f.get_value].pack("H*")
       if @length >  0
         raise TooLongDataException if out.length > @length
         out = out.ljust(@length,0.chr)
       end
-      return out
+      buf << out
+      return out.length
     end 
   end
 
@@ -157,33 +178,30 @@ module Codec
       "5C9F535455565758595AF4F5F6F7F8F930313233343536373839FAFBFCFDFEFF"].pack("H*")
   
   class Numace < Numstr
-    def build_field(buf,length)
-      f = Field.new(@id)
-      
+    def build_field(buffer, field, length)
       data = ""
+      buf = buffer.slice!(0...length)
       # if buf to decode is in EBCDIC then convert buf in ASCII
-      if ( buf[0,length].unpack("C*").select{|c| c >= 128}.size > 0)
-        buf[0,length].unpack("C*").each { |c| data += EBCDIC_2_ASCII[c] }
+      if ( buf.unpack("C*").select{|c| c >= 128}.size > 0)
+        buf.unpack("C*").each { |c| data << EBCDIC_2_ASCII[c] }
       else
-        data = buf[0,length]
+        data = buf
       end
-      f.set_value(data.to_i)
-      return f
+      field.set_value(data.to_i)
     end
   end
 
   class Strace < String
-    def build_field(buf,length)
-      f = Field.new(@id)
+    def build_field(buffer, field, length)
       data = ""
+      buf = buffer.slice!(0...length)
       # if buf to decode is in EBCDIC then convert buf in ASCII
-      if ( buf[0,length].unpack("C*").select{|c| c >= 128}.size > 0)
-        buf[0,length].unpack("C*").each { |c| data += EBCDIC_2_ASCII[c] }
+      if ( buf.unpack("C*").select{|c| c >= 128}.size > 0)
+        buf.unpack("C*").each { |c| data += EBCDIC_2_ASCII[c] }
       else
-        data = buf[0,length]
+        data = buf
       end
-      f.set_value(data)
-      return f
+      field.set_value(data)
     end
   end
 end