codec 0.0.2 → 0.0.4

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+

data/codec.gemspec

@@ -19,4 +19,5 @@ Gem::Specification.new do |spec|
   spec.version       = Codec::VERSION
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "log4r"
 end

data/lib/codec/base.rb

@@ -6,47 +6,45 @@ module Codec
         @id = id
     end
 
-    def build_field
+    def build_field(buf,length)
       f = Field.new(@id)
-      f.set_value(@data)
+      f.set_value(buf[0,length])
       return f
     end
     
     def decode_with_length(buf,length)
-      init_data(buf,length)
-      return build_field,@remain
+      l = eval_length(buf,length)
+      return build_field(buf,l),buf[l,buf.length]
     end
     
     def decode(buf)
-      init_data(buf,@length)
-      return build_field,@remain
+      l = eval_length(buf,@length)
+      return build_field(buf,l),buf[l,buf.length]
     end    
     
-    def init_data(buf,length)
+    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
-        @data = buf[0,length]
-        @remain = buf[length,buf.length]
+        return length
       else
-        @data = buf
-        @remain = ""
+        return buf.length
       end
     end
     
-    def add_subparser(id_field,parser)
-	    if parser.nil?
-	      raise InitializeException, "Invalid codec reference in subparser #{id_field} for codec #{@id}"
+    def add_sub_codec(id_field,codec)
+	    if codec.nil?
+	      raise InitializeException, "Invalid codec reference in subcodec #{id_field} for codec #{@id}"
 	    end
-      if @subParsers.kind_of? Hash
-        @subParsers[id_field] = parser 
+      if @subCodecs.kind_of? Hash
+        @subCodecs[id_field] = codec 
       end
     end 
 	
-	  def get_sub_parsers
-	    return @subParsers
+	  def get_sub_codecs
+	    return @subCodecs
 	  end
   end
 end

data/lib/codec/bitmap.rb

@@ -0,0 +1,102 @@
+module Codec
+  class Bitmap < Base
+    NB_BITS_BY_BYTE = 8
+    def initialize(id,length)
+      super(id,length)
+      @num_extended_bitmaps=[]
+      @subCodecs = {}
+    end
+    
+    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]
+      field_num = first_field_num
+      while(bitmapBuffer.length > 0)
+        fieldsList << field_num if bitmapBuffer.start_with?('1')
+        bitmapBuffer.slice!(0)
+        field_num += 1
+      end
+      return fieldsList, buf
+    end
+    
+    def encode_bitmap(fields_list,bitmap_index)
+      offset = bitmap_index * bitmap_length
+      bitmap = ""
+      ((offset + 1)..(offset + bitmap_length)).each do |i|
+        if fields_list.include?(i)
+          bitmap += "1"
+        else
+          bitmap += "0"
+        end
+      end
+      return [bitmap].pack("B*")
+    end
+    
+    def encode(field)
+      fields = field.get_value 
+      encoded_fields = []
+      fields_list = fields.collect{|id,sf| 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| [id,nil]}
+      fields.sort!{|a,b| a.first.to_i <=> b.first.to_i}
+      # Encode first bitmap
+      out = encode_bitmap(fields_list,0)
+      bitmap_index = 1
+      fields.each do |id,sf|
+        codec = @subCodecs[id]
+        if @num_extended_bitmaps.include?(id)
+          out += encode_bitmap(fields_list,bitmap_index)
+          bitmap_index += 1
+        elsif codec.nil?
+          raise EncodingException, "unknown codec for subfield #{id}"
+        elsif encoded_fields.include?(id.to_i)
+          raise EncodingException, "Multiple subfield #{id} is invalid for Codec::Bitmap"
+        else
+          out += codec.encode(sf)
+        end
+        encoded_fields << id.to_i
+      end
+      return out
+    end
+    
+    def decode(buffer)
+      msg = Field.new(@id)
+      field_num = 1
+      # 1. read bitmap
+      fields_list,buf = decodeBitmap(buffer,field_num)
+      field_num += bitmap_length
+      # 2. decode each field present
+      while fields_list.length > 0
+        # get next field number in bitmap
+        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)
+          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)
+          msg.add_sub_field(f)
+        else
+  	      f = Field.new("ERR") 
+  	      f.set_value(buf.unpack("H*").first)
+  	      msg.add_sub_field(f)
+          raise ParsingException,msg.to_yaml + "\nError unknown field #{field_tag} : "
+        end
+      end
+      return msg,buf
+    end
+  end
+end

data/lib/codec/composed.rb

@@ -0,0 +1,83 @@
+module Codec
+  class BaseComposed < Base
+    def initialize(id)
+      @id = id
+      @subCodecs = []
+    end
+    
+    def decode(buf)
+      return build_each_field(buf,buf.length)
+    end
+    
+    def encode(field)
+      subfields = field.get_value
+      composed_encoder = subfields.zip(@subCodecs).collect {|sf,sc|
+        if sf.first != sc.first
+          raise EncodingException, "subfield #{sf.first} not correspond to subcodec #{sc.first}"
+        end
+        [sc.last,sf.last]
+      } 
+      out = ""
+      composed_encoder.each do |subcodec,subfield|
+        out += subcodec.encode(subfield)
+      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}"
+        else
+          f,working_buf = codec.decode(working_buf)
+          f.set_id(id)
+          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
+      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
+    end
+    
+    def encode(field)
+      if @subCodecs.size != field.get_value.size
+        raise EncodingException, "Not enough subfields to encode #{@id}"
+      end
+      super(field)
+    end
+  end
+end

data/lib/codec/exceptions.rb

@@ -1,6 +1,13 @@
 module Codec
   class ParsingException < Exception
   end
+  
+  class EncodingException < Exception
+  end
+
+  class TooLongDataException < EncodingException
+  end
+  
 
   class InitializeException < Exception
   end

data/lib/codec/factory.rb

@@ -0,0 +1,4 @@
+module Codec
+ # TODO : implements codec factory
+ # - should permit to load codec from xml,yaml or json files
+end

data/lib/codec/field.rb

@@ -8,11 +8,28 @@ module Codec
   end
   
   class Field
-    def initialize(id="*")
+    def initialize(id="*",value="")
       @id = (id.nil? ? "*" : id)
-      @value = ""
+      @value = value
     end
-
+    
+    def self.from_array(id,fields_array)
+      f = Field.new(id)  
+      fields_array.each do |id,value|
+        if value.kind_of?(Array)
+          sf = Field.from_array(id,value)
+        else
+          sf = Field.new(id,value)
+        end
+        f.add_sub_field(sf)
+      end
+      return f
+    end
+    
+    def ==(other)
+      (@id == other.get_id && @value == other.get_value)
+    end
+    
     def get_id ; @id; end
     
     def set_id id ; @id = id ; end
@@ -22,6 +39,7 @@ module Codec
     def set_value(value)
 	    raise "Error can not set value that is instance of Array" if value.kind_of? Array
       @value = value
+      return self
     end
     
     def add_sub_field(sf)

data/lib/codec/fix.rb

@@ -1,48 +1,88 @@
 module Codec
   class Numbin < Base
-    def build_field
+    def build_field(buf,length)
       f = Field.new(@id)
       res = 0
-      @data.unpack("C*").each{ |ubyte|
+      buf[0,length].unpack("C*").each{ |ubyte|
         res *= 256
         res += ubyte
       }
       f.set_value(res)
       return f
     end
+    
+    def encode(field)
+      val = field.get_value.to_i
+      out = Numbin.numbin(val,@length)
+      return out
+    end
+    
+    def self.numbin(number,maxlength)
+      out = ""
+      while number > 0
+        out << (number % 256).chr
+        number /= 256
+      end
+      
+      # handle length if defined
+      if maxlength > 0
+        while out.length < maxlength
+          out << 0.chr
+        end
+        out = out[0,maxlength]
+      end
+      return out.reverse
+    end
   end
 
-
-  
-  class Numstr < Base
-    def build_field
+  class Numasc < Base
+    def build_field(buf,length)
       f = Field.new(@id)
-	  # Force conversion of ebcdic number to ascii number
-	  if IsEbcdic(@data)
-	    @data = Ebcdic2Ascii(@data)
-	  end
-	  
-      f.set_value(@data.to_i)
+      f.set_value(buf[0,length].to_i)
       return f
     end
+    
+    def encode(field)
+      out = field.get_value.to_s
+      if @length > 0
+        out = out.rjust(@length,"0")
+        raise TooLongDataException if out.length > @length
+      end
+      return out
+    end
   end
 
   class String < Base
-    def build_field
+    def build_field(buf,length)
       f = Field.new(@id)
-	  if IsEbcdic(@data)
-	    @data = Ebcdic2Ascii(@data)
-	  end
-      f.set_value(@data)
+      f.set_value(buf[0,length])
       return f
     end
+    
+    def encode(f)
+      out = f.get_value
+      if @length >  0
+        raise TooLongDataException if out.length > @length
+        out = out.ljust(@length," ")
+      end
+      return out
+    end    
   end
 
   class Binary < Base
-    def build_field
+    def build_field(buf,length)
       f = Field.new(@id)
-      f.set_value(@data.unpack("H*").first.upcase)
+      f.set_value(buf[0,length].unpack("H*").first.upcase)
       return f
     end
+    
+    def encode(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
+    end 
   end
 end

data/lib/codec/packed.rb

@@ -0,0 +1,68 @@
+module Codec
+  class Packed < Base
+    def get_pck_length(length)
+      ((length + 1) / 2)
+    end
+    
+    def eval_pck_length(field)
+      if @length > 0
+        return @length 
+      else
+        return field.get_value.to_s.length
+      end
+    end	
+    
+    def decode_with_length(buf,length)
+      l = eval_length(buf,get_pck_length(length))
+      return build_field(buf,l),buf[l,buf.length]
+    end
+    
+    def decode(buf)
+      return decode_with_length(buf,@length)
+    end
+  end
+
+  class Numpck < Packed
+    def build_field(buf,length)
+      f = Field.new(@id)
+      f.set_value(buf[0,length].unpack("H*").first.to_i)
+      return f
+    end
+    
+    def encode(field)
+      out = field.get_value.to_s
+      if @length > 0
+        out = out.rjust(@length,"0")
+        raise TooLongDataException if out.length > @length
+      end
+      l = out.length
+      out.prepend("0") if out.length.odd?
+      out = [out].pack("H*")
+      return out
+    end
+  end
+  
+  class Strpck < Packed
+    def build_field(buf,length)
+      f = Field.new(@id)
+      val = buf[0,length].unpack("H*").first
+      # TODO : handle odd length for packed field with prefixed length
+      val.chop! if @length.odd?
+      f.set_value(val)
+      return f
+    end
+    
+    def encode(field)
+      out = field.get_value.to_s
+      if @length > 0
+        out = out.ljust(@length,"F")
+        raise TooLongDataException if out.length > @length
+      end
+      l = out.length
+      out += "F" if out.length.odd?
+      out = [out].pack("H*")
+      return out
+    end
+  end
+
+end

data/lib/codec/prefix.rb

@@ -0,0 +1,136 @@
+module Codec
+  class Prefixedlength < Base
+    def initialize(id,length,content)
+      # TODO : Check that value_codec has a null length attribute
+      @length_codec = length
+      @value_codec = content
+      @id = id
+    end
+	
+    def get_length(length_field)
+    	length_field.get_value.to_i
+    end
+	
+    def decode(buffer)
+      l, buf = @length_codec.decode(buffer)
+	    len = get_length(l)
+	    if len == 0
+	      f = Field.new
+		    f.set_id(@id)
+		    f.set_value(nil)
+		    return f,buf
+	    else
+	      begin
+		      f,remain = @value_codec.decode_with_length(buf,len)
+		    rescue => e
+		      Logger.error "Error in #{@id} decoder \n #{e.message}\n#{e.backtrace.join(10.chr)}"
+		      raise ParsingException, e.message
+		    end
+        
+        f.set_id(@id)
+        return f,remain
+	    end
+    end
+	
+	  def build_field(buf,length)
+	    begin
+	      f,r = decode(buf[0,length])
+	    rescue ErrorBufferUnderflow => e
+	      raise ParsingException, e.message
+	    end
+	    Logger.error "Error remain data in Prefixedlength" if r != ""
+	    return f
+	  end
+    
+    def encode(field)
+      val = @value_codec.encode(field)
+      length = @length_codec.encode(Field.new.set_value(val.length))
+      out = length + val
+      return out
+    end
+  end
+
+  class Headerlength < Prefixedlength
+    def initialize(id,header,content,length_path)
+      @path = length_path # length attribute contain the path for length field in header
+      @separator = @path.slice!(0).chr # first character contain the separator
+      super(id,header,content)
+    end
+	
+	  def get_length(header_field)
+      return header_field.get_value.to_i if @path.length == 0 # Handle simple numeric header field
+	  	length_field = header_field.get_deep_field(@path,@separator)
+	  	if length_field.nil?
+	  	  return 0
+	  	else
+	  	  length_field.get_value.to_i
+	  	end
+	  end
+
+	  def decode(buffer)
+	    f = Field.new
+	    f.set_id(@id)
+	    head, buf = @length_codec.decode(buffer)
+	    head.set_id(@length_codec.id)
+	    f.add_sub_field(head)
+	    len = get_length(head)
+	    if len == 0
+	      return f,buf
+	    else
+        len -= (buffer.length - buf.length) if @header_length_include
+	      val,remain = @value_codec.decode_with_length(buf,len)
+        val.set_id(@value_codec.id)
+	  	  f.add_sub_field(val)
+        return f,remain
+	    end
+	  end
+    
+    def encode(field)
+      # encode content
+      content = @value_codec.encode(field.get_sub_field(@value_codec.id))
+      head_field = field.get_sub_field(@length_codec.id)
+      length_field = head_field.get_deep_field(@path,@separator)
+      if length_field.nil?
+        raise EncodingException,"Length field #{@path} is not present in header for encoding #{@id} =>
+        #{field.to_yaml}"
+      end
+      # update length field in header
+      length_field.set_value(content.length)
+      # encode header
+      header =  @length_codec.encode(head_field)
+      return header + content
+    end
+  end  
+
+  class Headerfulllength < Headerlength
+    # TODO : to implement
+  end
+  
+  class Tagged < Base
+    def initialize(id,tag_codec)
+      @subCodecs = {}
+      @tag_codec = tag_codec
+	    @id = id
+    end
+    
+    def decode(buffer)
+      tag,buf = @tag_codec.decode(buffer)
+      if @subCodecs[tag.get_value.to_s].nil?
+        raise ParsingException, "Unknown tag #{tag.get_value.to_s} for #{@id} decoder"
+      end
+      f,buf = @subCodecs[tag.get_value.to_s].decode(buf)
+      f.set_id(tag.get_value.to_s)
+      return f,buf
+    end
+    
+    def encode(field)
+      head = Field.new(@tag_codec.id, field.get_id)
+      out = @tag_codec.encode(head)
+      if @subCodecs[field.get_id].nil?
+        raise EncodingException, "Unknown tag #{field.get_id} for #{@id} encoder"
+      end
+      out += @subCodecs[field.get_id].encode(field)
+      return out
+    end
+  end
+end