format_parser 2.2.1 → 2.4.3

data/spec/parsers/iso_base_media_file_format/box_spec.rb

@@ -0,0 +1,399 @@
+require 'spec_helper'
+
+describe FormatParser::ISOBaseMediaFileFormat::Box do
+  describe '.new' do
+    context 'when no fields/children' do
+      subject { described_class.new('foo', 0, 0) }
+
+      it 'sets them as empty hash/array' do
+        expect(subject.fields).to eq({})
+        expect(subject.children).to eq([])
+      end
+    end
+
+    context 'when fields/children' do
+      let(:fields) { { foo: 1, bar: 'bar' } }
+      let(:children) { [described_class.new('bar', 0, 0)] }
+
+      subject { described_class.new('foo', 0, 0, fields, children) }
+
+      it 'sets them correctly' do
+        expect(subject.fields).to eq(fields)
+        expect(subject.children).to eq(children)
+      end
+    end
+  end
+
+  describe '#all_children' do
+    context 'when no types given' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0)
+        ])
+      end
+
+      it 'returns empty array' do
+        expect(subject.all_children).to eq([])
+      end
+    end
+
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns empty array' do
+        expect(subject.all_children('foo')).to eq([])
+      end
+    end
+
+    context 'when no children of given type(s)' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0, nil, [
+            described_class.new('baz', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns empty array' do
+        expect(subject.all_children('baz')).to eq([])
+      end
+    end
+
+    context 'when multiple children of given type(s)' do
+      let(:child_1) { described_class.new('foo', 0, 0) }
+      let(:child_2) do
+        described_class.new('foo', 0, 0, nil, [
+          described_class.new('qux', 0, 0)
+        ])
+      end
+      let(:child_3) { described_class.new('bar', 0, 0) }
+
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          child_1,
+          child_2,
+          child_3,
+          described_class.new('baz', 0, 0)
+        ])
+      end
+
+      it 'returns all matching direct children' do
+        expect(subject.all_children('foo', 'bar', 'qux')).to match_array([child_1, child_2, child_3])
+      end
+    end
+  end
+
+  describe '#child?' do
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns false' do
+        expect(subject.child?('foo')).to eq(false)
+      end
+    end
+
+    context 'when no children of given type' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0, nil, [
+            described_class.new('baz', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns false' do
+        expect(subject.child?('baz')).to eq(false)
+      end
+    end
+
+    context 'when child of given type' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0),
+        ])
+      end
+
+      it 'returns true' do
+        expect(subject.child?('foo')).to eq(true)
+      end
+    end
+  end
+
+  describe '#first_child' do
+    context 'when no types given' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0)
+        ])
+      end
+
+      it 'returns nil' do
+        expect(subject.first_child).to eq(nil)
+      end
+    end
+
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns nil' do
+        expect(subject.first_child('foo')).to eq(nil)
+      end
+    end
+
+    context 'when no children of given type(s)' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0, nil, [
+            described_class.new('baz', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns nil' do
+        expect(subject.first_child('baz')).to eq(nil)
+      end
+    end
+
+    context 'when multiple children of given type(s)' do
+      let(:child) { described_class.new('bar', 0, 0) }
+
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            described_class.new('qux', 0, 0)
+          ]),
+          child,
+          described_class.new('bar', 0, 0),
+          described_class.new('baz', 0, 0)
+        ])
+      end
+
+      it 'returns first matching direct child' do
+        expect(subject.first_child('qux', 'baz', 'bar')).to eq(child)
+      end
+    end
+  end
+
+  describe '#all_descendents' do
+    context 'when no types given' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0)
+        ])
+      end
+
+      it 'returns empty array' do
+        expect(subject.all_descendents).to eq([])
+      end
+    end
+
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns empty array' do
+        expect(subject.all_descendents('root', 'foo')).to eq([])
+      end
+    end
+
+    context 'when no descendents of given type(s)' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0, nil, [
+            described_class.new('baz', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns empty array' do
+        expect(subject.all_descendents('root', 'qux')).to eq([])
+      end
+    end
+
+    context 'when multiple descendents of given type(s)' do
+      let(:descendent_1) { described_class.new('bar', 0, 0) }
+      let(:descendent_2) { described_class.new('baz', 10, 10, nil, [descendent_3]) }
+      let(:descendent_3) { described_class.new('bar', 20, 20) }
+
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            descendent_1
+          ]),
+          descendent_2,
+          described_class.new('qux', 40, 40)
+        ])
+      end
+
+      it 'returns all matching descendents' do
+        expect(subject.all_descendents('bar', 'baz')).to match_array([descendent_1, descendent_2, descendent_3])
+      end
+    end
+  end
+
+  describe '#all_descendents_by_path' do
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns empty array' do
+        expect(subject.all_descendents_by_path(['foo'])).to eq([])
+      end
+    end
+
+    context 'when no path' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            described_class.new('bar', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns empty array' do
+        expect(subject.all_descendents_by_path([])).to eq([])
+      end
+    end
+
+    context 'when no descendents at given path' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            described_class.new('bar', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns empty array' do
+        expect(subject.all_descendents_by_path(%w[foo baz])).to eq([])
+      end
+    end
+
+    context 'when multiple descendents at given path' do
+      let(:descendent_1) { described_class.new('bar', 0, 0) }
+      let(:descendent_2) { described_class.new('bar', 0, 0) }
+
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            descendent_1,
+            described_class.new('baz', 0, 0, nil, [
+              described_class.new('bar', 0, 0)
+            ]),
+            descendent_2,
+          ])
+        ])
+      end
+
+      it 'returns all matching descendents' do
+        expect(subject.all_descendents_by_path(%w[foo bar])).to match_array([descendent_1, descendent_2])
+      end
+    end
+  end
+
+  describe '#first_descendent' do
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns nil' do
+        expect(subject.first_descendent('root', 'foo')).to eq(nil)
+      end
+    end
+
+    context 'when no descendents of given type(s)' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0),
+          described_class.new('bar', 0, 0, nil, [
+            described_class.new('baz', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns nil' do
+        expect(subject.first_descendent('root', 'qux')).to eq(nil)
+      end
+    end
+
+    context 'when multiple descendents of given type(s)' do
+      let(:descendent) { described_class.new('bar', 0, 0) }
+
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            descendent
+          ]),
+          described_class.new('bar', 0, 0),
+        ])
+      end
+
+      it 'returns first matching descendent' do
+        expect(subject.first_descendent('bar')).to be(descendent)
+      end
+    end
+  end
+
+  describe '#first_descendent_by_path' do
+    context 'when no children' do
+      subject { described_class.new('root', 0, 0) }
+
+      it 'returns nil' do
+        expect(subject.first_descendent_by_path(['foo'])).to eq(nil)
+      end
+    end
+
+    context 'when no path' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            described_class.new('bar', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns nil' do
+        expect(subject.first_descendent_by_path([])).to eq(nil)
+      end
+    end
+
+    context 'when no descendents at given path' do
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            described_class.new('bar', 0, 0)
+          ])
+        ])
+      end
+
+      it 'returns nil' do
+        expect(subject.first_descendent_by_path(%w[foo baz])).to eq(nil)
+      end
+    end
+
+    context 'when multiple descendents at given path' do
+      let(:descendent) { described_class.new('bar', 0, 0) }
+
+      subject do
+        described_class.new('root', 0, 0, nil, [
+          described_class.new('foo', 0, 0, nil, [
+            described_class.new('baz', 0, 0, nil, [
+              described_class.new('bar', 0, 0)
+            ]),
+            descendent,
+            described_class.new('bar', 0, 0),
+          ])
+        ])
+      end
+
+      it 'returns first matching descendent' do
+        expect(subject.first_descendent_by_path(%w[foo bar])).to eq(descendent)
+      end
+    end
+  end
+end

data/spec/parsers/iso_base_media_file_format/decoder_spec.rb

@@ -1,14 +1,24 @@
 require 'spec_helper'
 
 describe FormatParser::ISOBaseMediaFileFormat::Decoder do
-  context 'when build_atom_tree is called' do
-    context 'with no io' do
-      it 'raises an error' do
-        expect { subject.build_atom_tree(0x0) }.to raise_error(/IO missing - supply a valid IO object/)
+  describe '#build_box_tree' do
+    context 'when IO not provided' do
+      context 'when IO not previously provided' do
+        it 'raises an error' do
+          expect { subject.build_box_tree(0x0) }.to raise_error(/IO missing - supply a valid IO object/)
+        end
+      end
+
+      context 'when IO previously provided' do
+        let(:io) { StringIO.new('') }
+        it 'does not raise an error' do
+          expect(subject.build_box_tree(0x0, io)).to eq([])
+          expect(subject.build_box_tree(0x0)).to eq([])
+        end
       end
     end
 
-    context('with a max_read smaller than the length of the IO') do
+    context 'when max_read smaller than IO length' do
       let(:io) do
         # moov
         # moov
@@ -17,41 +27,36 @@ describe FormatParser::ISOBaseMediaFileFormat::Decoder do
       end
 
       it 'stops building the tree' do
-        expect(subject.build_atom_tree(0x0, io).length).to eq(0)
+        expect(subject.build_box_tree(0x0, io).length).to eq(0)
         expect(io.pos).to eq(0)
 
-        expect(subject.build_atom_tree(0x8, io).length).to eq(1)
+        expect(subject.build_box_tree(0x8, io).length).to eq(1)
         expect(io.pos).to eq(0x8)
         io.seek(0)
 
-        expect(subject.build_atom_tree(0x10, io).length).to eq(2)
+        expect(subject.build_box_tree(0x10, io).length).to eq(2)
         expect(io.pos).to eq(0x10)
       end
     end
 
-    context 'when parsing an unknown atom' do
+    context 'when parsing unknown box' do
       let(:io) do
         # foo
         # |-> moov
         input = [0x14].pack('N') + 'foo ' + [0x1].pack('N') + [0x8].pack('N') + 'moov'
         StringIO.new(input)
       end
+      let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it 'parses only the type, position and size, and skips any fields and children' do
-        result = subject.build_atom_tree(0xFF, io)
-        expect(result.length).to eq(1)
-        expect(io.pos).to eq(0x14)
-
-        foo_atom = result[0]
-        expect(foo_atom.type).to eq('foo ')
-        expect(foo_atom.position).to eq(0)
-        expect(foo_atom.size).to eq(0x14)
-        expect(foo_atom.fields).to eq({})
-        expect(foo_atom.children).to eq([])
-      end
+      it('parses successfully') { expect(result.length).to eq(1) }
+      it('parses the correct type') { expect(result[0].type).to eq('foo ') }
+      it('parses the correct position') { expect(result[0].position).to eq(0) }
+      it('parses the correct size') { expect(result[0].size).to eq(0x14) }
+      it('skips additional fields') { expect(result[0].fields).to eq({}) }
+      it('skips children') { expect(result[0].children).to eq([]) }
     end
 
-    context 'when parsing a container atom' do
+    context 'when parsing a container box' do
       let(:io) do
         # moov
         # |-> foo
@@ -59,184 +64,54 @@ describe FormatParser::ISOBaseMediaFileFormat::Decoder do
         input = [0x18].pack('N') + 'moov' + [0x8].pack('N') + 'foo ' + [0x8].pack('N') + 'bar '
         StringIO.new(input)
       end
+      let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it 'parses type, position, size and children' do
-        result = subject.build_atom_tree(0xFF, io)
-        expect(result.length).to eq(1)
-        expect(io.pos).to eq(0x18)
-
-        moov_atom = result[0]
-        expect(moov_atom.type).to eq('moov')
-        expect(moov_atom.position).to eq(0)
-        expect(moov_atom.size).to eq(0x18)
-        expect(moov_atom.fields).to eq({})
-        expect(moov_atom.children.length).to eq(2)
-      end
+      it('parses successfully') { expect(result.length).to eq(1) }
+      it('parses the correct type') { expect(result[0].type).to eq('moov') }
+      it('parses the correct position') { expect(result[0].position).to eq(0) }
+      it('parses the correct size') { expect(result[0].size).to eq(0x18) }
+      it('skips additional fields') { expect(result[0].fields).to eq({}) }
+      it('parses children') { expect(result[0].children.length).to eq(2) }
     end
 
-    context 'when parsing an empty atom' do
+    context 'when parsing an empty box' do
       let(:io) do
         # nmhd
         # |-> foo
         input = [0x18].pack('N') + 'nmhd' + [0x1].pack('c') + 'fla' + [0x2].pack('N') + [0x8].pack('N') + 'foo '
         StringIO.new(input)
       end
+      let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it 'parses type, position, size, version and flags, and skips any other fields or children' do
-        result = subject.build_atom_tree(0xFF, io)
-        expect(result.length).to eq(1)
-        expect(io.pos).to eq(0x18)
-
-        nmhd_atom = result[0]
-        expect(nmhd_atom.type).to eq('nmhd')
-        expect(nmhd_atom.position).to eq(0)
-        expect(nmhd_atom.size).to eq(0x18)
-        expect(nmhd_atom.fields).to include({
+      it('parses successfully') { expect(result.length).to eq(1) }
+      it('parses the correct type') { expect(result[0].type).to eq('nmhd') }
+      it('parses the correct position') { expect(result[0].position).to eq(0) }
+      it('parses the correct size') { expect(result[0].size).to eq(0x18) }
+      it('parses version and flags') do
+        expect(result[0].fields).to include({
           version: 1,
           flags: 'fla'
         })
-        expect(nmhd_atom.children).to eq([])
       end
+      it('skips children') { expect(result[0].children).to eq([]) }
     end
 
-    context 'when parsing a uuid atom' do
+    context 'when parsing a uuid box' do
       let(:usertype) { '90f7c66ec2db476b977461e796f0dd4b' }
       let(:io) do
-        input = [0x20].pack('N') + 'uuid' + [usertype].pack('H*') + [0x8].pack('N') + 'foo '
-        StringIO.new(input)
-      end
-
-      it 'parses type, position, size and usertype, and skips any other fields or children' do
         # uuid
         # |-> foo
-        result = subject.build_atom_tree(0xFF, io)
-        expect(result.length).to eq(1)
-        expect(io.pos).to eq(0x20)
-
-        nmhd_atom = result[0]
-        expect(nmhd_atom.type).to eq('uuid')
-        expect(nmhd_atom.position).to eq(0)
-        expect(nmhd_atom.size).to eq(0x20)
-        expect(nmhd_atom.fields).to include({
-          usertype: usertype,
-        })
-        expect(nmhd_atom.children).to eq([])
-      end
-    end
-  end
-end
-
-describe FormatParser::ISOBaseMediaFileFormat::Decoder::Atom do
-  context 'when initialized' do
-    context 'without fields and/or children' do
-      subject { described_class.new('foo', 0, 0) }
-
-      it 'sets them as an empty array/hash' do
-        expect(subject.type).to eq('foo')
-        expect(subject.position).to eq(0)
-        expect(subject.size).to eq(0)
-        expect(subject.fields).to eq({})
-        expect(subject.children).to eq([])
-      end
-    end
-
-    context 'with fields and/or children' do
-      let(:fields) { { foo: 1, bar: 'bar' } }
-      let(:children) { [described_class.new('bar', 0, 0)] }
-
-      subject { described_class.new('foo', 0, 0, fields, children) }
-
-      it 'sets them correctly' do
-        expect(subject.type).to eq('foo')
-        expect(subject.position).to eq(0)
-        expect(subject.size).to eq(0)
-        expect(subject.fields).to eq(fields)
-        expect(subject.children).to eq(children)
-      end
-    end
-  end
-
-  context 'when find_first_descendent is called' do
-    context 'with no children' do
-      subject { described_class.new('root', 0, 0) }
-      it 'returns nil' do
-        expect(subject.find_first_descendent(%w[root foo])).to be_nil
-      end
-    end
-
-    context 'with no descendents of the given type(s)' do
-      subject do
-        described_class.new('root', 0, 0, nil, [
-          described_class.new('foo', 0, 0),
-          described_class.new('bar', 0, 0, nil, [
-            described_class.new('baz', 0, 0)
-          ])
-        ])
-      end
-
-      it 'returns nil' do
-        expect(subject.find_first_descendent(%w[root qux])).to be_nil
-      end
-    end
-
-    context 'with multiple descendents of the given type(s)' do
-      let(:descendent) { described_class.new('bar', 0, 0) }
-
-      subject do
-        described_class.new('root', 0, 0, nil, [
-          described_class.new('foo', 0, 0, nil, [
-            descendent
-          ]),
-          described_class.new('bar', 0, 0),
-        ])
-      end
-
-      it 'returns the first relevant descendent in order of appearance' do
-        expect(subject.find_first_descendent(%w[bar])).to be(descendent)
-      end
-    end
-  end
-
-  context 'when select_descendents is called' do
-    context 'with no children' do
-      subject { described_class.new('root', 0, 0) }
-      it 'returns an empty array' do
-        expect(subject.select_descendents(%w[root foo])).to eq([])
-      end
-    end
-
-    context 'with no descendents of the given type(s)' do
-      subject do
-        described_class.new('root', 0, 0, nil, [
-          described_class.new('foo', 0, 0),
-          described_class.new('bar', 0, 0, nil, [
-            described_class.new('baz', 0, 0)
-          ])
-        ])
-      end
-
-      it 'returns an empty array' do
-        expect(subject.select_descendents(%w[root qux])).to eq([])
-      end
-    end
-
-    context 'with multiple descendents of the given type(s)' do
-      let(:descendent_1) { described_class.new('bar', 0, 0) }
-      let(:descendent_3) { described_class.new('bar', 20, 20) }
-      let(:descendent_2) { described_class.new('baz', 10, 10, nil, [descendent_3]) }
-
-      subject do
-        described_class.new('root', 0, 0, nil, [
-          described_class.new('foo', 0, 0, nil, [
-            descendent_1
-          ]),
-          descendent_2,
-        ])
+        input = [0x20].pack('N') + 'uuid' + [usertype].pack('H*') + [0x8].pack('N') + 'foo '
+        StringIO.new(input)
       end
+      let(:result) { subject.build_box_tree(0xFF, io) }
 
-      it 'returns all relevant descendents' do
-        expect(subject.select_descendents(%w[bar baz])).to match_array([descendent_1, descendent_2, descendent_3])
-      end
+      it('parses successfully') { expect(result.length).to eq(1) }
+      it('parses the correct type') { expect(result[0].type).to eq('uuid') }
+      it('parses the correct position') { expect(result[0].position).to eq(0) }
+      it('parses the correct size') { expect(result[0].size).to eq(0x20) }
+      it('parses usertype') { expect(result[0].fields).to include({ usertype: usertype }) }
+      it('skips children') { expect(result[0].children).to eq([]) }
     end
   end
 end