julik-depix 1.0.2 → 1.0.3

data/History.txt

@@ -1,4 +1,9 @@
-=== 1.0.2 / 2008-12-23
+=== 1.0.4 / 2008-12-25
+
+* Add brief inspect
+* Add metadata editing
+
+=== 1.0.3 / 2008-12-23
 
 * Do not cleanup null bytes and terminators in the middle of char[] attributes (something useful might be in there)
 

data/Manifest.txt

@@ -7,9 +7,13 @@ bin/depix-describe
 lib/depix.rb
 lib/depix/struct_explainer.rb
 lib/depix/structs.rb
+lib/depix/benchmark.rb
 lib/depix/compact_structs.rb
 lib/depix/enums.rb
 lib/depix/dict.rb
+lib/depix/reader.rb
+lib/depix/editor.rb
+test/test_dict.rb
 test/test_depix.rb
 test/samples/E012_P001_L000002_lin.0001.dpx
 test/samples/E012_P001_L000002_lin.0002.dpx

data/README.txt

@@ -4,12 +4,22 @@
 
 == DESCRIPTION:
 
-Read DPX file metadata
+Read and write DPX file metadata
 
 == SYNOPSIS:
 
+Reading headers
+
   meta = Depix.from_file(dpx_file_path)
   puts meta.time_code #=> 10:00:00:02
+
+Writing headers
+  
+  editor = Depix::Editor.new(dpx_file_path)
+
+  # Advance the time code by one frame and save
+  editor.headers.time_code = editor.headers.time_code + 1
+  editor.commit!
   
 The data returned is described in the DPX_HEADER_STRUCTURE[link:files/DPX_HEADER_STRUCTURE_txt.html]. It's
 a vanilla Ruby object with no extra methods except for the readers that have the same name as the specified
@@ -19,11 +29,15 @@ The gem also contains an executable called depix-desribe which can be used from
   
   $book depix-describe 001_PTAPE_001.001.dpx
 
-== NOTES:
+for a long description or 
+
+  $book depix-describe -s 001_PTAPE_001.001.dpx 
 
-In the future there will be a possibility to modify and commit the headers, but it's not a priority at this time.
+for a short description
+
+== NOTES:
 
-Autodesk IFFS systems write the reel name for the file to the orientation.device field
+Autodesk IFFS systems write the reel name for the file to the orientation.device field, some scanners write it into user data.
 
 == REQUIREMENTS:
 

data/bin/depix-describe

@@ -10,13 +10,24 @@ OptionParser.new do |opts|
   opts.on("-c", "--compact", "Compact output (only fields that change per frame)") do |v|
     options[:compact] = true
   end
+
+  opts.on("-s", "--synthetics", "Output only synthetic fields (like time code and aspect)") do |v|
+    options[:synthetics] = true
+  end
+
 end.parse!
 
 ARGV.each do | file |
-  puts "Describing DPX #{file}. Empty elements are omitted.\n\n"
-  puts "===================================================\n\n"
+  puts "Describing DPX #{file}. Empty elements are omitted."
+  puts "===================================================\n"
   begin
-    puts Depix.describe_file(file, options[:compact])
+    if options[:synthetics]
+      puts Depix.describe_brief(file)
+    elsif options[:compact]
+      puts Depix.describe_file(file, true)
+    else
+      puts Depix.describe_file(file)
+    end
   rescue Depix::InvalidHeader
     puts " - Invalid header data"
   end

data/lib/depix/benchmark.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../depix'
+
+require 'benchmark'
+
+iter = 10000
+
+puts "Reading DPX header #{iter} times, all data"
+puts Benchmark.measure {
+  iter.times { Depix.from_file(File.dirname(__FILE__)+"/../../test/samples/026_FROM_HERO_TAPE_5-3-1_MOV.0029.dpx", false) }
+}
+
+puts "Reading DPX header #{iter} times, compact data"
+puts Benchmark.measure {
+  iter.times { Depix.from_file(File.dirname(__FILE__)+"/../../test/samples/026_FROM_HERO_TAPE_5-3-1_MOV.0029.dpx", true) }
+}

data/lib/depix/dict.rb

@@ -50,6 +50,26 @@ module Depix
     def consume!(stack)
       clean(stack.shift)
     end
+    
+    # Check that the passed value:
+    # a) Matches the Ruby type expected
+    # b) Fits into the slot
+    # c) Does not overflow
+    # When the validation fails should raise
+    def validate!(value)
+      raise "#{name} value required, but got nil in #{name}".strip if value.nil? && req?
+      raise "Value expected to be #{rtype} but was #{value.class}" if !value.nil? && rtype && !value.is_a?(rtype)
+    end
+    
+    # Pack a value passed into a string
+    def pack(value)
+      raise "No pattern defined for #{self}" unless pattern
+      if value.nil?
+        [self.class.const_get(:BLANK)].pack(pattern)
+      else
+        [value].pack(pattern)
+      end
+    end
   end
   
   class U32Field < Field
@@ -67,6 +87,14 @@ module Depix
     def clean(value)
       value == BLANK ? nil : value
     end
+    
+    # Override - might be Bignum although cast to Integer sometimes
+    def validate!(value)
+      raise "#{name} value required, but got nil".strip if value.nil? && req?
+      raise "#{name} value expected to be #{rtype} but was #{value.class}" if !value.nil? && (!value.is_a?(Integer) && !value.is_a?(Bignum))
+      raise "#{name} value #{value} overflows" if !value.nil? && (value < 0 || value >= BLANK)
+    end
+    
   end
   
   class U8Field < Field
@@ -87,7 +115,12 @@ module Depix
     end
     
     def clean(v)
-      v == BLANK ? nil : v
+      (v == BLANK || v == -1) ? nil : v
+    end
+    
+    def validate!(value)
+      super(value)
+      raise "#{name} value #{value} out of bounds for 8 bit unsigned int".lstrip if (!value.nil? && (value < 0 || value >= BLANK))
     end
   end
   
@@ -101,6 +134,10 @@ module Depix
     def consume(stack)
       nil
     end
+    
+    def pack(data)
+      raise "This is a filler, it cannot be reconstructed from a value"
+    end
   end
     
   class U16Field < Field
@@ -122,10 +159,16 @@ module Depix
     def clean(v)
       v == BLANK ? nil : v
     end
+    
+    def validate!(value)
+      super(value)
+      raise "#{name} value #{value} out of bounds for 16bit unsigned int" if (value < 0 || value >= BLANK)
+    end
   end
   
   class R32Field < Field
     undef :length=, :pattern=
+    BLANK = 0xFFFFFFFF
     
     def pattern
       "g"
@@ -169,6 +212,15 @@ module Depix
     def rtype
       String
     end
+    
+    def validate!(value)
+      super(value)
+      raise "#{value} overflows the #{length} bytes allocated" if !value.nil? && value.length > length
+    end
+    
+    def pack(value)
+      value.ljust(length, "\000") rescue ("\000" * length)
+    end
   end
   
   # Wrapper for an array structure
@@ -198,6 +250,27 @@ module Depix
       r = (req? ? "- required" : nil)
       [tpl, desc, r].compact.join(' ')
     end
+    
+    def validate!(array)
+      raise "This value would overflow, #{array.length} elements passed but only #{members.length} fit" unless array.length <= members.length
+      raise "This value is required, but the array is empty" if req? && array.empty?
+      array.zip(members).map do | v, m | 
+        m.validate!(v) unless (v.nil? && !m.req?)
+      end
+    end
+    
+    def pack(values)
+      # For members that are present, get values. For members that are missing, fill with null bytes upto length.
+      # For values that are nil, skip packing
+      members.zip(values).map do |m, v| 
+        if !m.req? && v.nil?
+          raise "#{m} needs to provide length" unless m.length
+          "\377" * m.length
+        else
+          v.respond_to?(:pack) ? v.pack : m.pack(v)
+        end
+      end.join
+    end
   end
   
   # Wrapper for a contained structure
@@ -220,6 +293,15 @@ module Depix
     def rtype
       cast
     end
+    
+    def validate!(value)
+      super(value)
+      cast.validate!(value) if cast.respond_to?(:validate!) && (!value.nil? || req?)
+    end
+    
+    def pack(value)
+      cast.pack(value)
+    end
   end
   
   # Base class for a struct. Could also be implemented as a module actually
@@ -232,7 +314,14 @@ module Depix
       def fields
         @fields ||= []
       end
-
+      
+      # Validate a passed instance
+      def validate!(instance)
+        fields.each do | f |
+          f.validate!(instance.send(f.name)) if f.name
+        end
+      end
+      
       # Define a 4-byte unsigned integer
       def u32(name, *extras)
         count, opts = count_and_opts_from(extras)
@@ -273,6 +362,7 @@ module Depix
         else
           [Field.send("emit_#{mapped_to}")] * count
         end
+        yield a.members if block_given?
         fields << a
       end
       
@@ -343,6 +433,41 @@ module Depix
         only([])
       end
       
+      # Pack the instance of this struct
+      def pack(instance, buffer = nil)
+        
+        # Preallocate a buffer just as big as me since we want everything to remain at fixed offsets
+        buffer ||= ("\000" * length)
+        
+        # If the instance is nil return pure padding
+        return buffer if instance.nil?
+        
+        # Now for the important stuff. For each field that we have, replace a piece at offsets in the buffer
+        # with the packed results, skipping fillers
+        fields.each_with_index do | f, i |
+          
+          # Skip blanking, we just dont touch it. TODO - test!
+          next if f.is_a?(Filler)
+          
+          # Where should we put that value?
+          offset = fields[0...i].inject(0){|_, s| _ + s.length }
+
+          val = instance.send(f.name)
+
+          # Validate the passed value using the format the field supports
+          f.validate!(val)
+          
+          packed = f.pack(val)
+          
+          # Signal offset violation
+          raise "Improper length for #{f.name} - packed #{packed.length} bytes but #{f.length} is required to fill the slot" if packed.length != f.length
+
+          buffer[offset...(offset+f.length)] = packed
+        end
+        raise "Resulting buffer not the same length, expected #{length} bytes but compued #{buffer.length}" if buffer.length != length
+        buffer
+      end
+      
       private
 
       # extract_options! on a diet

data/lib/depix/editor.rb

@@ -0,0 +1,32 @@
+module Depix
+  # Used to edit DPX headers. Create an Editor object and pass the path to the file to it. Change the headers variable to contain the edited
+  # DPX headers and call commit!. Note that the DPX header will be overwritten in place - if you want to save another version you need to manage it yourself
+  class Editor
+
+    # Stores the path to file
+    attr_reader :path
+    
+    # Stores the Depix::DPX object with headers
+    attr_accessor :headers
+    
+    # Create a new editor for the file at path
+    def initialize(file_path)
+      @path = file_path
+      @headers = Depix.from_file(@path)
+    end
+    
+    # Save the headers to file at path, overwriting the old ones
+    def commit!
+      raise "No headers" unless @headers
+      raise "Cannot pack LE headers" if @headers.le?
+      packed = @headers.class.pack(@headers)
+      
+      # Validate that we can unpack first - what if something went wrong?
+      Depix::Reader.new.parse(packed, false)
+      
+      File.open(@path, 'rb+') do | f |
+        f.seek(0, IO::SEEK_SET); f.write(packed)
+      end
+    end
+  end
+end

data/lib/depix/reader.rb

@@ -0,0 +1,83 @@
+module Depix
+  class Reader
+  
+    # Returns a printable report on all the headers present in the file at the path passed
+    def describe_file(path, compact = false)
+      header = File.open(path, 'r') { |f| f.read(DPX.length) }
+      struct = parse(header, false)
+      describe_struct(struct) + describe_synthetics_of_struct(struct)
+    end
+  
+    def describe_synthetics_of_struct(struct)
+      Synthetics.instance_methods.reject{|m| m.include?('=')}.map do | m |
+        [m, struct.send(m)].join(' : ')
+      end.unshift("============").unshift("\nSynthetic properties").join("\n")
+    end
+  
+    def from_file(path, compact)
+      header = File.open(path, 'r') { |f| f.read(DPX.length) }
+      begin
+        parse(header, compact)
+      rescue InvalidHeader => e
+        raise InvalidHeader, "Invalid header in file #{path} - #{e.message}"
+      end
+    end
+  
+    # The hear of Depix
+    def parse(data, compact)
+      magic = data[0..3]
+    
+      raise InvalidHeader, "No magic bytes found at start" unless %w( SDPX XPDS).include?(magic)
+    
+      struct = compact ? CompactDPX : DPX
+    
+      is_be = (magic == "SDPX")
+      version_check = FileInfo.only(:magic, :version)
+    
+      result = begin
+        if is_be
+          version_check.consume!(data.unpack(version_check.pattern))
+        else
+          version_check.consume!(data.unpack(make_le(version_check.pattern)))
+        end
+      rescue ArgumentError
+        raise InvalidHeader
+      end
+    
+      raise InvalidHeader, "Unknown version tag #{result.version}" unless result.version == "V1.0"
+     
+      template = is_be ? DPX.pattern : make_le(DPX.pattern)
+      struct.consume!(data.unpack(struct.pattern))
+    end
+  
+    # Describe a filled DPX structure
+    def describe_struct(result, pad_offset = 0)
+      result.class.fields.inject([]) do | info, field |
+        value = result.send(field.name)
+        parts = []
+        if value
+          parts << field.desc if field.desc
+          parts << if field.is_a?(InnerField)
+            describe_struct(value, pad_offset + 1)
+          elsif field.is_a?(ArrayField)
+            # Exception for image elements
+            value = result.image_elements[0...result.number_elements] if field.name == :image_elements
+            value.map { | v | v.is_a?(Dict) ? describe_struct(v, pad_offset + 2) : v }
+          else
+            value
+          end
+        end
+        if parts.any?
+          info << parts.join(' ')
+        end
+        info
+      end.map{|e| ('  ' * pad_offset) + e }.join("\n")
+    end
+  
+    # Convert an unpack pattern to LE
+    def make_le(pattern)
+      pattern.gsub(/n/, "v").gsub(/N/, "V").gsub(/g/, "f")
+    end
+  
+  end
+end

data/lib/depix/structs.rb

@@ -121,17 +121,26 @@ module Depix
     
     u32 :pixels_per_line,                   :desc => 'Pixels per horizontal line', :req => true
     u32 :lines_per_element,                 :desc => 'Line count', :req => true
-    array :image_elements, ImageElement, 8, :desc => "Image elements"
+    
+    array :image_elements, ImageElement, 8, :desc => "Image elements" do | elements |
+      elements[0].req = true
+    end
+    
     char :reserve, 52
+    
+    # Only expose the elements present
+    def image_elements #:nodoc:
+      @image_elements[0...number_elements]
+    end
   end
   
   #:include:DPX_HEADER_STRUCTURE.txt
   class DPX < Dict
-    inner :file, FileInfo,   :desc => "File information"
-    inner :image, ImageInfo, :desc => "Image information"
-    inner :orientation, OrientationInfo, :desc => "Orientation"
-    inner :film, FilmInfo, :desc => "Film industry info"
-    inner :television, TelevisionInfo, :desc => "TV industry info"
-    inner :user, UserInfo, :desc => "User info"
+    inner :file, FileInfo,   :desc => "File information", :req => true
+    inner :image, ImageInfo, :desc => "Image information", :req => true
+    inner :orientation, OrientationInfo, :desc => "Orientation", :req => true
+    inner :film, FilmInfo, :desc => "Film industry info", :req => true
+    inner :television, TelevisionInfo, :desc => "TV industry info", :req => true
+    inner :user, UserInfo, :desc => "User info", :req => true
   end
 end

data/lib/depix.rb

@@ -1,4 +1,3 @@
-require 'stringio'
 require 'rubygems'
 require 'timecode'
 
@@ -6,14 +5,18 @@ require File.dirname(__FILE__) + '/depix/dict'
 require File.dirname(__FILE__) + '/depix/structs'
 require File.dirname(__FILE__) + '/depix/compact_structs'
 require File.dirname(__FILE__) + '/depix/enums'
+require File.dirname(__FILE__) + '/depix/reader'
+require File.dirname(__FILE__) + '/depix/editor'
+
 
 module Depix
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
   
   class InvalidHeader < RuntimeError; end
   
   # Offers convenience access to a few common attributes bypassing the piecemeal structs
   module Synthetics
+    
     def keycode
       [film.id, film.type, film.offset, film.prefix, film.count].compact.join(' ')
     end
@@ -21,13 +24,23 @@ module Depix
     # Return the flame reel name. The data after the first null byte is not meant to be seen and is used by Flame internally
     # as it seems
     def flame_reel
-      orientation.device.split("\000").shift
+      orientation.device.split(0x00.chr).shift
+    end
+    
+    # Assign reel name
+    def flame_reel=(new_reel)
+      orientation.device = new_reel
     end
     
     def time_code
       Timecode.from_uint(television.time_code) #, film.frame_rate)
     end
     
+    # Assign frame rate and timecode from a Timecode object
+    def time_code=(new_tc)
+      television.time_code, film.frame_rate = new_tc.to_uint, new_tc.fps
+    end
+    
     # Get the name of the transfer function (Linear, Logarithmic, ...)
     def colorimetric
       COLORIMETRIC.invert[image.image_elements[0].colorimetric]
@@ -38,6 +51,11 @@ module Depix
       COMPONENT_TYPE.invert[image.image_elements[0].descriptor]
     end
     
+    # Aspect in it's traditional repr
+    def aspect
+      "%.2f" % (orientation.aspect_ratio[0].to_f / orientation.aspect_ratio[1].to_f)
+    end
+    
     # Is this DPX file little-endian? This would be an exception, but still useful
     def le?
       file.magic == 'XPDS'
@@ -65,78 +83,9 @@ module Depix
     Reader.new.describe_file(path, compact)
   end
   
-  class Reader
-    
-    # Returns a printable report on all the headers present in the file at the path passed
-    def describe_file(path, compact = false)
-      header = File.open(path, 'r') { |f| f.read(DPX.length) }
-      describe_struct(parse(header, false))
-    end
-    
-    def from_file(path, compact)
-      header = File.open(path, 'r') { |f| f.read(DPX.length) }
-      begin
-        parse(header, compact)
-      rescue InvalidHeader => e
-        raise InvalidHeader, "Invalid header in file #{path}"
-      end
-    end
-    
-    # The hear of Depix
-    def parse(data, compact)
-      magic = data[0..3]
-      
-      raise InvalidHeader unless %w( SDPX XPDS).include?(magic)
-      
-      struct = compact ? CompactDPX : DPX
-      
-      is_be = (magic == "SDPX")
-      version_check = FileInfo.only(:magic, :version)
-      
-      result = begin
-        if is_be
-          version_check.consume!(data.unpack(version_check.pattern))
-        else
-          version_check.consume!(data.unpack(make_le(version_check.pattern)))
-        end
-      rescue ArgumentError
-        raise InvalidHeader
-      end
-      
-      raise InvalidHeader unless result.version == "V1.0"
-       
-      template = is_be ? DPX.pattern : make_le(DPX.pattern)
-      struct.consume!(data.unpack(struct.pattern))
-    end
-    
-    # Describe a filled DPX structure
-    def describe_struct(result, pad_offset = 0)
-      result.class.fields.inject([]) do | info, field |
-        value = result.send(field.name)
-        parts = []
-        if value
-          parts << field.desc if field.desc
-          parts << if field.is_a?(InnerField)
-            describe_struct(value, pad_offset + 1)
-          elsif field.is_a?(ArrayField)
-            # Exception for image elements
-            value = result.image_elements[0...result.number_elements] if field.name == :image_elements
-            value.map { | v | v.is_a?(Dict) ? describe_struct(v, pad_offset + 2) : v }
-          else
-            value
-          end
-        end
-        if parts.any?
-          info << parts.join(' ')
-        end
-        info
-      end.map{|e| ('  ' * pad_offset) + e }.join("\n")
-    end
-    
-    # Convert an unpack pattern to LE
-    def make_le(pattern)
-      pattern.gsub(/n/, "v").gsub(/N/, "V").gsub(/g/, "f")
-    end
-    
+  # Return a formatted description of the DPX file at path, showing only synthetic attributes
+  def self.describe_brief(path)
+    Reader.new.describe_synthetics_of_struct(from_file(path))
   end
+  
 end

data/test/test_depix.rb

@@ -1,10 +1,10 @@
 require File.dirname(__FILE__) + '/../lib/depix'
 require 'test/unit'
 
+SAMPLE_DPX = File.dirname(__FILE__) + '/samples/E012_P001_L000002_lin.0001.dpx'
+
 class ReaderTest < Test::Unit::TestCase
   
-  SAMPLE_DPX = File.dirname(__FILE__) + '/samples/E012_P001_L000002_lin.0001.dpx'
-    
   def test_parsed_properly
     file = SAMPLE_DPX
     parsed = Depix.from_file(file)
@@ -69,6 +69,7 @@ class ReaderTest < Test::Unit::TestCase
     assert_equal :RGB, parsed.component_type
     assert_equal :Linear, parsed.colorimetric
     assert_equal "E012", parsed.flame_reel
+    assert_equal "1.33", parsed.aspect
   end
   
   def test_parsed_properly_using_compact_structs
@@ -84,6 +85,17 @@ class ReaderTest < Test::Unit::TestCase
     end
   end
   
+  def test_packing
+    original_header = File.read(SAMPLE_DPX)[0...Depix::DPX.length]
+    
+    assert_nothing_raised do
+      dpx = Depix.from_string(original_header)
+      packed =  Depix::DPX.pack(dpx, original_header.dup)
+    
+      dpx2 = Depix.from_string(packed)
+    end
+  end
+  
   def test_parsing_something_else_should_raise
     s = "Mary had a little lamb"
     assert_raise(Depix::InvalidHeader) { Depix.from_string(s) }
@@ -95,4 +107,29 @@ class ReaderTest < Test::Unit::TestCase
     assert_raise(Depix::InvalidHeader) { Depix.from_string(s) }
 
   end
+end
+
+class EditorTest < Test::Unit::TestCase
+  def test_instantiation
+    e = Depix::Editor.new(SAMPLE_DPX)
+    assert_not_nil e
+    assert_equal SAMPLE_DPX, e.path
+    assert_not_nil e.headers
+  end
+  
+  def test_commit
+    temp_path = SAMPLE_DPX + ".test"
+    begin
+      FileUtils.cp(SAMPLE_DPX, temp_path)
+      e  = Depix::Editor.new(temp_path)
+      e.headers.orientation.device = "E013"
+
+      assert_nothing_raised { e.commit! }
+
+      re_read = Depix.from_file(temp_path)
+      assert_equal "E013", re_read.orientation.device
+    ensure
+      File.unlink(temp_path)
+    end
+  end
 end

data/test/test_dict.rb

@@ -3,6 +3,28 @@ require 'test/unit'
 
 include Depix
 
+class BogusError < RuntimeError; end
+
+class AlwaysInvalidField < Field
+  def validate!(value)
+    raise BogusError, "Never valid"
+  end
+  
+  def pack(some_value)
+    raise BogusError, "Will not pack"
+  end
+end
+
+class AlwaysInvalidStruct
+  def self.validate!(value)
+    raise BogusError, "Never valid"
+  end
+  
+  def self.pack(instance)
+    raise BogusError, "Will not pack"
+  end
+end
+
 module FieldConformity
   def conform_field!(f)
     assert_respond_to f, :name
@@ -12,6 +34,8 @@ module FieldConformity
     assert_respond_to f, :req?
     assert_respond_to f, :rtype
     assert_respond_to f, :explain
+    assert_respond_to f, :validate!
+    assert_respond_to f, :pack
   end
   
   def assert_method_removed(f, method)
@@ -99,24 +123,24 @@ class TestField < Test::Unit::TestCase
     assert_equal [2,3], ar
   end 
   
-  def test_consume_for_inner_field
-    catcher = Class.new do
-      def self.consume!(arg)
-        raise RuntimeError if arg == ["julik"]
-      end
-    end
-    
-    f = InnerField.new :cast => catcher
-    assert_respond_to f, :consume!
+  def test_validate
+    f = Field.new
+    f.rtype = self.class
+    assert_nothing_raised { f.validate! nil }
     
-    assert_raise(RuntimeError) { f.consume!(["julik"]) }
+    assert_raise(RuntimeError) { f.validate! "boo" }
+    assert_nothing_raised { f.validate! self }
   end
   
-  def test_consume_for_array
-    f = ArrayField.new :members => [Field.new, Field.new]
-    assert_respond_to f, :consume!
-    
-    assert_equal [1,2], f.consume!([1,2])
+  def test_validate_if_required
+    f = Field.new
+    f.req = true
+    assert_raise(RuntimeError) { f.validate! nil }
+  end
+  
+  def test_pack_raises
+    f = Field.new
+    assert_raise(RuntimeError) { f.pack("foo")}
   end
 end
 
@@ -159,6 +183,59 @@ class TestArrayField < Test::Unit::TestCase
     assert_equal 3, f.length
     assert_equal "CC2", f.pattern
   end
+  
+  def test_consume
+    f = ArrayField.new :members => [Field.new, Field.new]
+    assert_respond_to f, :consume!
+    
+    assert_equal [1,2], f.consume!([1,2])
+  end
+  
+  def test_validate
+    f = ArrayField.new :members => [Field.new(:rtype => self.class)]
+    
+    # Overflow
+    assert_raise(RuntimeError) { f.validate!([nil, nil]) }
+    
+    # Just empty
+    assert_nothing_raised { f.validate!([]) }
+    
+    # Nil vaue
+    assert_nothing_raised { f.validate!([nil]) }
+
+    # type cast
+    assert_raise(RuntimeError) { f.validate!(["nil"]) }
+
+    assert_nothing_raised { f.validate!([self]) }
+  end
+  
+  def test_validate_fails_with_empty_array_and_required_field
+    f = ArrayField.new :members => [Field.new(:rtype => self.class)], :req => true
+    assert_raise(RuntimeError) { f.validate!([]) }
+  end
+  
+  def test_validate_does_not_validate_inner_structure_if_no_value_present_and_field_is_not_required
+    f = ArrayField.new :members => [AlwaysInvalidField.new]
+    assert_nothing_raised { f.validate! [nil] }
+  end
+  
+  
+  def test_pack_tries_to_pack_inner_structures
+    f = ArrayField.new :members => [AlwaysInvalidField.new]
+    assert_raise(BogusError) { f.pack([1, 2]) }
+  end
+  
+  def test_pack_pads_properly
+    f = ArrayField.new :members => [U32Field.new, R32Field.new, R32Field.new]
+    assert_equal "\000\000\000\001@\000\000\000\377\377\377\377", f.pack([1.0, 2.0])
+    assert_equal f.length, f.pack([1.0, 2.0]).length
+  end
+
+  def test_does_not_try_to_pack_nil_values
+    f = ArrayField.new(:members => [AlwaysInvalidField.new(:length => 2)])
+    assert_equal "\377\377", f.pack([])
+  end
+
 end
 
 class TestInnerField < Test::Unit::TestCase
@@ -194,6 +271,34 @@ class TestInnerField < Test::Unit::TestCase
     casted = InnerField.new(:cast => c)
     assert_equal c, casted.rtype
   end
+  
+  def test_consume
+    catcher = Class.new do
+      def self.consume!(arg)
+        raise RuntimeError if arg == ["julik"]
+      end
+    end
+    
+    f = InnerField.new :cast => catcher
+    assert_respond_to f, :consume!
+    
+    assert_raise(RuntimeError) { f.consume!(["julik"]) }
+  end
+  
+  def test_validate_with_nil_and_no_requirement
+    f = InnerField.new :cast => AlwaysInvalidStruct, :req => true
+    assert_raise(RuntimeError) { f.validate!(nil) }
+  end
+  
+  def test_validate
+    f = InnerField.new :cast => AlwaysInvalidStruct
+    assert_raise(BogusError) { f.validate!(AlwaysInvalidStruct.new) }
+  end
+  
+  def test_pack_tries_to_pack_inner_structures
+    f = InnerField.new :cast => AlwaysInvalidStruct
+    assert_raise(BogusError) { f.pack(AlwaysInvalidStruct.new) }
+  end
 end
 
 class TestWideIntField < Test::Unit::TestCase
@@ -209,6 +314,23 @@ class TestWideIntField < Test::Unit::TestCase
     assert_equal 66, f.clean(66)
     assert_equal nil, f.clean(0xFFFFFFFF)
   end
+  
+  def test_validate
+    f = U32Field.new
+    
+    assert_nothing_raised { f.validate! 8 }
+    assert_nothing_raised { f.validate! 0 }
+    assert_nothing_raised { f.validate!  65536 }
+    assert_raise(RuntimeError) { f.validate!(0xFFFFFFFF) }
+    assert_nothing_raised { f.validate!(0xFFFFFFFF - 1) }
+    
+  end
+  
+  def test_pack
+    w = U32Field.new
+    assert_equal "\000\000\000\036", w.pack(30)
+    assert_equal "\377\377\377\377", w.pack(nil)
+  end
 end
 
 class TestCharField < Test::Unit::TestCase
@@ -240,7 +362,25 @@ class TestCharField < Test::Unit::TestCase
     assert_equal nil, f.clean("\0\0\0\0\0\0")
     assert_equal nil, f.clean("\0\0\0\377\377\0\0\0")
     assert_equal "foo\0foo", f.clean("\0\0foo\0foo\0")
-
+  end
+  
+  def test_char_field_validates_overflow
+    f = CharField.new :length => 2
+    assert_raise(RuntimeError) { f.validate!("xxx")}
+    assert_nothing_raised { f.validate!("xx")}
+    assert_nothing_raised { f.validate!(nil)}
+  end
+  
+  def test_char_field_validates_required_with_nil
+    f = CharField.new :length => 2, :req => true
+    assert_raise(RuntimeError) { f.validate!(nil)}
+  end
+  
+  def test_char_field_packs
+    f = CharField.new(:length => 6)
+    assert_equal "xx\000\000\000\000", f.pack("xx")
+    assert_equal "\000\000\000\000\000\000", f.pack("")
+    assert_equal "\000\000\000\000\000\000", f.pack(nil)
   end
 end
 
@@ -261,6 +401,12 @@ class TestFloatField < Test::Unit::TestCase
     assert_equal Float, f.rtype
     assert_equal nil, f.clean(the_nan)
   end
+  
+  def test_pack
+    w = R32Field.new
+    assert_equal "@fff", w.pack(3.6)
+    assert_equal "O\200\000\000", w.pack(nil)
+  end
 end
 
 class TestSmallintField < Test::Unit::TestCase
@@ -272,7 +418,6 @@ class TestSmallintField < Test::Unit::TestCase
     
     assert_method_removed(f, :pattern=)
     assert_method_removed(f, :length=)
-    
   end
   
   def test_smallint_operation
@@ -285,11 +430,18 @@ class TestSmallintField < Test::Unit::TestCase
   
   def test_smallint_clean
     f = U8Field.new
-    
     assert_equal nil, f.clean(0xFF)
     assert_equal 10, f.clean(10)
   end
   
+  def test_validate
+    f = U8Field.new
+    assert_nothing_raised { f.validate! 8 }
+    assert_nothing_raised { f.validate! 0 }
+    assert_raise(RuntimeError) { f.validate!( -1 ) }
+    assert_raise(RuntimeError) { f.validate!( 255) }
+    assert_raise(RuntimeError) { f.validate!( 256) }
+  end
 end
 
 class TestDoubleField < Test::Unit::TestCase
@@ -317,6 +469,15 @@ class TestDoubleField < Test::Unit::TestCase
     assert_equal nil, f.clean(0xFFFF)
     assert_equal 10, f.clean(10)
   end
+  
+  def test_validate
+    f = U16Field.new
+    assert_nothing_raised { f.validate! 8 }
+    assert_nothing_raised { f.validate! 0 }
+    assert_raise(RuntimeError) { f.validate!( -1) }
+    assert_raise(RuntimeError) { f.validate!(  65535) }
+    assert_raise(RuntimeError) { f.validate!(  65536) }
+  end
 end
 
 class TestFillerField < Test::Unit::TestCase
@@ -344,7 +505,10 @@ class TestFillerField < Test::Unit::TestCase
     data.freeze
     assert_nothing_raised { Filler.new(:length => 1).consume(data) }
   end
-
+  
+  def test_pack_raises
+    assert_raise(RuntimeError) { Filler.new(:length => 3).pack('xxx') }
+  end
 end
 
 class TestFieldEmit < Test::Unit::TestCase
@@ -401,6 +565,12 @@ class TestDict < Test::Unit::TestCase
     assert_equal [], dict_class.fields
   end
   
+  def test_dict_responds_to_validate
+    dict_class = Class.new(Dict)
+    assert_respond_to dict_class, :validate!
+    one = dict_class.new
+  end
+  
   def test_dict_fields_array_not_class_shared
     d1, d2 = (0..1).map{|_| Class.new(Dict) }
     
@@ -434,7 +604,27 @@ class TestDict < Test::Unit::TestCase
     assert_equal 'A1A1', c.pattern
     assert_equal 2, c.length
   end
+
+  def test_dict_does_not_validate_inner_nil
+    wrapper_class = Class.new(Dict) do 
+      u32 :bigint
+      inner :invalid, AlwaysInvalidStruct
+    end
+    struct = wrapper_class.new
+    assert_nothing_raised { wrapper_class.validate!(struct) }
+  end
   
+  def test_dict_calls_validate
+    wrapper_class = Class.new(Dict) do 
+      u32 :bigint
+      inner :invalid, AlwaysInvalidStruct, :req => true
+    end
+    
+    struct = wrapper_class.new
+    struct.invalid = AlwaysInvalidStruct.new
+    
+    assert_raise(BogusError) { wrapper_class.validate!(struct) }
+  end
 end
 
 class TestDictConsume < Test::Unit::TestCase
@@ -449,6 +639,7 @@ class TestDictConsume < Test::Unit::TestCase
     assert_equal "a", result.foo
     assert_equal "b", result.bar
   end
+  
 end
 
 class TestDictEmitDSL < Test::Unit::TestCase

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: julik-depix
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-22 00:00:00 -08:00
+date: 2008-12-26 00:00:00 -08:00
 default_executable: depix-describe
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,15 +43,18 @@ files:
 - lib/depix.rb
 - lib/depix/struct_explainer.rb
 - lib/depix/structs.rb
+- lib/depix/benchmark.rb
 - lib/depix/compact_structs.rb
 - lib/depix/enums.rb
 - lib/depix/dict.rb
+- lib/depix/reader.rb
+- lib/depix/editor.rb
+- test/test_dict.rb
 - test/test_depix.rb
 - test/samples/E012_P001_L000002_lin.0001.dpx
 - test/samples/E012_P001_L000002_lin.0002.dpx
 - test/samples/E012_P001_L000002_log.0001.dpx
 - test/samples/E012_P001_L000002_log.0002.dpx
-- test/test_dict.rb
 has_rdoc: true
 homepage: http://wiretap.rubyforge.org/depix
 post_install_message: