flvedit 0.6.1 → 0.6.2

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 6
-:patch: 1
+:patch: 2

data/lib/flv/edit/processor/add.rb

@@ -6,11 +6,13 @@ module FLV
   module Edit
     module Processor
 
+      # Add is a Processor (see Base and desc)
       class Add < Base
         desc "Adds tags from the xml or yaml file PATH (default: tags.yaml/xml)", :param => {:name => "[PATH]"}
+
+        include Dispatcher
         
-        def initialize(*)
-          super
+        def on_header(tag)
           @add = (options[:add_tags] || read_tag_file).sort_by(&:timestamp)
         end
         

data/lib/flv/edit/processor/base.rb

@@ -1,140 +1,62 @@
 module FLV
   module Edit  
     module Processor
-      # Processors are used to process FLV files. Processors form are chain and the data (header and tags) will 'flow'
-      # through the chain in sequence. Each processor can inspect the data and change the flow,
-      # either by modifying the data, inserting new data in the flow or stopping the propagation of data.
+      # Base is the base class for all Processors.
+      # Processors are used to process FLV files.
+      # A FLV file can be seen as an enumeration of chunks, the first one being a Header and the following ones
+      # a series of Tags with different types of bodies: Audio, Video or Event.
+      # A Processor acts as an IO operation on such enumerations.
+      # They therefore take an enumeration of chunks as input and their output is similarly an enumeration of chunks.
+      # They can thus be chained together at will.
       #
-      # A FLV file can be seen as a sequence of chunks, the first one being a Header and the following ones
-      # a series of Tags with different types of bodies: Audio, Video or Event. Events store all meta data
-      # related information: onMetaData, onCuePoint, ...
+      # For example:
+      #   FLV::File.open("x.flv") do |f|
+      #     Debug.new(Cut.new(f, :cut => "1m-")).first(10)
+      #   end
+      #   # ==> reads the file, skips the first minute, prints and returns the first 10 chunks
       #
-      # To tap into the flow of chunks, a processor can define any of the following methods:
-      #   on_chunk
-      #     on_header
-      #     on_tag
-      #       on_audio
-      #       on_video
-      #         on_keyframe
-      #         on_interframe
-      #         on_disposable_interframe
-      #       on_event
-      #         on_meta_data
-      #         on_cue_point
-      #         on_other_event
-      #
-      # All of these methods will have one argument: the current chunk being processed.
-      # For example, if the current chunk is an 'onMetaData' event, then
-      # the following will be called (from the most specialized to the least).
-      #   processor.on_meta_data(chunk)
-      #   processor.on_event(chunk)
-      #   processor.on_chunk(chunk)
-      #   # later on, the next processor will handle it:
-      #   next_processor.on_meta_data(chunk)
-      #   #...
-      #
-      # The methods need not return anything. It is assumed that the chunk will continue to flow through the
-      # processing chain. When the chunk should not continue down the chain, call +absorb+.
-      # To insert other tags in the flow, call +dispatch_instead+.
-      # Finally, it's possible to +stop+ the processing of the file completely.
-      #
-      # It is possible to look back at already processed chunks (up to a certain limit) with +look_back+
-      # or even in the future with +look_ahead+
+      # Processors acts as Enumerable, but #each, in that context, is an enumeration of chunks
+      # for one single file. Some processors act as more than one such enumeration (Reader, Split)
+      # To go through all, call #each_source or #process_all
       #
       class Base
+        include Enumerable
         attr_reader :options
 
+        # Create a new processor, using the given +source+ and +options+ hash.
+        # Valid +options+ depend on the class of Processor.
         def initialize(source=nil, options={})
-          @options = options.freeze
+          @options = options.reverse_merge(:out => STDOUT)
           @source = source
-          on_calls = self.class.instance_methods(false).select{|m| m.to_s.start_with?("on_")}.map(&:to_sym) #Note: to_s needed for ruby 1.9, to_sym for ruby 1.8
-          unless (potential_errors = on_calls - ALL_EVENTS).empty?
-            warn "The following are not events: #{potential_errors.join(',')} (class #{self.class})"
-          end
         end
 
-        def has_next_file?
-          @source.has_next_file?
-        end
-
-        def rewind
-          @source.rewind
-        end
-
-        def absorb(*) # Note: the (*) is so that we can alias events like on_meta_data
-          throw :absorb
-        end
-      
-        def stop
-          throw :stop
-        end
-      
-        def process_all
-          each{} while has_next_file?
+        # Calls the given block once for each source
+        def each_source(&block)
+          raise "There is no source for #{self}" unless source
+          source.each_source(&block)
         end
 
+        # Calls the given block once for each chunck, passing that chunk as argument
         def each(&block)
-          return to_enum(:each_chunk) unless block_given?
-          @block = block
-          catch :stop do
-            process_next_file
-          end
-        end
-      
-        def process_next_file
-          dispatch_chunks(@source)
-        end
-        
-        def dispatch_chunks(enum)
-          enum.each do |chunk|
-            dispatch_chunk(chunk)
-          end
-        end
-
-        def dispatch_chunk(chunk)
-          evt = chunk.main_event
-          catch :absorb do
-            EVENT_TRIGGER_LIST[evt].each do |event|
-              send(event, chunk) if respond_to?(event)
-            end
-            @block.call chunk
-          end
+          raise "There is no source for #{self}" unless source
+          source.each(&block)
         end
       
-        def dispatch_instead(*chunks)
-          chunks.each do |chunk|
-            @block.call chunk
-          end
-          absorb
-        end
-
-        def stdout
-          options[:out] || STDOUT
+        # Simple utility going through each chunk of each source
+        def process_all
+          each_source{each{}}
         end
 
-        EVENT_TRIGGER = {
-          :on_header      => :on_chunk,
-          :on_tag         => :on_chunk,
-          :on_audio       => :on_tag,
-          :on_video       => :on_tag,
-          :on_event       => :on_tag,
-          :on_meta_data   => :on_event,
-          :on_cue_point   => :on_event,
-          :on_last_second => :on_event,
-          :on_other_event => :on_event,
-          :on_keyframe    => :on_video,
-          :on_interframe  => :on_video,
-          :on_disposable_interframe => :on_video
-        }.freeze
-      
-        ALL_EVENTS = (EVENT_TRIGGER.keys | EVENT_TRIGGER.values).freeze
-      
-        MAIN_EVENTS = ALL_EVENTS.reject{ |k| EVENT_TRIGGER.has_value?(k)}.freeze
-      
-        EVENT_TRIGGER_LIST = Hash.new{|h, k| h[k] = [k] + h[EVENT_TRIGGER[k]]}.tap{|h| h[nil] = []; h.values_at(*MAIN_EVENTS)}.freeze
-      
       protected
-      
+        attr_reader :source
+        
+        # Processors can be made directly accessible to the command line by calling #desc
+        # with a description.
+        # Options are:
+        # * :shortcut => "x" (defaults to first letter of processor)
+        # * :param => pass a hash if the command line should accept a parameter:
+        #   * :class => class of the parameter (defaults to String)
+        #   * :name => name of parameter, surrounded with [] if optional (defaults to the name of the class)
         def self.desc(text, options = {})
           registry << [self, text, options]
         end
@@ -143,67 +65,23 @@ module FLV
           @@registry ||= []
         end
     
-        def self.absorb(*events)
-          events.each{|evt| alias_method evt, :absorb}
-        end
-        
       end #class Base
 
+      # Utility function to create a chain of Processors.
+      # Example:
+      #   chain(Update, Debug, Cut, options)
+      #   # ==> Update.new(Debug.new(Cut.new(options),options),options)
       def self.chain(chain_classes, options = {})
         next_chain_class = chain_classes.pop
         next_chain_class.new(chain(chain_classes, options), options) if next_chain_class
       end
-
-      # Let's extend the different kinds of chunks so that any_chunk.main_event returns
-      # the desired trigger.
-
-      module MainEvent # :nodoc:
-        module Header
-          def main_event
-            :on_header
-          end
-        end
-
-        module Video
-          MAPPING = {
-            :keyframe => :on_keyframe,
-            :interframe => :on_interframe,
-            :disposable_interframe => :on_disposable_interframe
-          }.freeze
-
-          def main_event
-            MAPPING[frame_type]
-          end
-        end
-
-        module Audio
-          def main_event
-            :on_audio
-          end
-        end
-
-        module Event
-          MAPPING = Hash.new(:on_other_event).merge!(
-            :onMetaData => :on_meta_data,
-            :onCuePoint => :on_cue_point,
-            :onLastSecond => :on_last_second
-          ).freeze
-          def main_event
-            MAPPING[event]
-          end
-        end
-        
-        module Tag
-          def main_event
-            body.main_event
-          end
-        end
-      end #module MainEvent
     end #module Processor
   end #module Edit
   
-  [Header, Tag, Audio, Video, Event].each do |klass|
-    klass.class_eval{ include Edit::Processor::MainEvent.const_get(klass.to_s.sub('FLV::', '')) }
+  module File
+    # A file acts as a single source, so...
+    def each_source
+      yield
+    end
   end
-  
 end #module FLV

data/lib/flv/edit/processor/command_line.rb

@@ -1,19 +1,26 @@
 module FLV
   module Edit
     module Processor
+
+      # CommandLine is a Processor (see Base) added automatically as the last level
+      # for all command line executions
       class CommandLine < Base
+        include Dispatcher
         def on_header(h)
           @last = h.path
         end
       
-        def process_all
+        def each_source
+          return to_enum(:each_source) unless block_given?
           ok, errors = [], []
-          begin
-            each{}
-            ok << @last
-          rescue Exception => e
-            errors << [@last, e]
-          end while has_next_file?
+          super do
+            begin
+              each{}
+              ok << @last
+            rescue Exception => e
+              errors << [@last, e]
+            end
+          end
           puts (["Processed successfully:"] + ok).join("\n") unless ok.empty?
           puts (["**** Processed with errors: ****"] + errors.map{|path, err| "#{path}: #{err}"}).join("\n") unless errors.empty?
         end

data/lib/flv/edit/processor/cut.rb

@@ -1,21 +1,27 @@
 module FLV
   module Edit  
     module Processor
+
+      # Cut is a Processor class (see Base and desc)
       class Cut < Base
-        desc ["Cuts file using the given RANGE"],
+        desc ["Cuts selects the tags within RANGE.",
+              "The timestamps are offset so that the first tag as timestamp 0"],
               :param => {:class => TimestampRange, :name => "RANGE"}, :shortcut => "x"
 
-        def on_header(*)
+        include Filter
+
+        def before_filter
           @from, @to = options[:cut].begin, options[:cut].end
           @wait_for_keyframe = options[:keyframe_mode]
           @first_timestamp = nil
         end
 
-        def on_tag(tag)
+        def filter(tag)
+          return if tag.is_a? Header
           if tag.timestamp > @to
             stop
           elsif (tag.timestamp < @from) || (@wait_for_keyframe &&= !tag.body.is?(:keyframe))
-            absorb
+            :skip
           else
             @first_timestamp ||= tag.timestamp
             tag.timestamp -= @first_timestamp

data/lib/flv/edit/processor/debug.rb

@@ -3,27 +3,29 @@ require_relative "printer"
 module FLV
   module Edit  
     module Processor
+
+      # Debug is a Processor class (see Base and desc)
       class Debug < Base
+        include Filter
         desc ["Prints out the details of all tags. Information that stays the same",
               "from one tag type to the next will not be repeated.",
               "A RANGE argument will limit the output to tags within that range;",
               "similarily, a given TIMESTAMP will limit the output to tags",
               "within 0.1s of this timestamp."],
             :param => {:class => TimestampOrTimestampRange, :name => "[RANGE/TS]"}
-        def on_header(tag)
+
+        def before_filter
           @range = self.options[:debug] || TimestampRange.new(0, INFINITY)
           @range = @range.widen(0.1) unless @range.is_a? Range
           @last = {}
-          @printer = Printer.new(stdout)
-          tag.debug(@printer) if @range.include? 0
+          @printer = Printer.new(options[:out])
         end
-
-        def on_tag(tag)
+        
+        def filter(tag)
           return unless @range.include? tag.timestamp
           tag.debug(@printer, @last[tag.body.class])
           @last[tag.body.class] = tag
         end
-
       end
     end
   end

data/lib/flv/edit/processor/dispatcher.rb

@@ -0,0 +1,175 @@
+module FLV
+  module Edit  
+    module Processor
+
+      # Dispatcher can be included in a processor and will makeit easy to 
+      # process the chunks according to their type.
+      #
+      # Chunks can be Header or Tags.
+      # The latter have different types of bodies: Audio, Video or Event.
+      # Events store all meta data related information: onMetaData, onCuePoint, ...
+      #
+      # To tap into the flow of chunks, a processor can define any of the following methods:
+      #   on_chunk
+      #     on_header
+      #     on_tag
+      #       on_audio
+      #       on_video
+      #         on_keyframe
+      #         on_interframe
+      #         on_disposable_interframe
+      #       on_event
+      #         on_meta_data
+      #         on_cue_point
+      #         on_other_event
+      #
+      # All of these methods will have one argument: the current chunk being processed.
+      # For example, if the current chunk is an 'onMetaData' event, then
+      # the following will be called (from the most specialized to the least).
+      #   on_meta_data(chunk)
+      #   on_event(chunk)
+      #   on_chunk(chunk)
+      #
+      # The methods need not return anything. It is assumed that the chunk should be output.
+      # If that's not the case, call +#absorb+.
+      # To output other tags instead, call +#dispatch_instead+.
+      #
+      # Note that both #absorb and #dispatch_instead stop the processing for the current chunk,
+      # so if #on_video calls #absorb, for example, then there won't be a call to #on_tag or #on_chunk.
+      #
+      # Finally, it's possible to +#stop+ the processing of the current source completely.
+      #
+      module Dispatcher
+        def initialize(*)
+          super
+          on_calls = self.class.instance_methods(false).select{|m| m.to_s.start_with?("on_")}.map(&:to_sym) #Note: to_s needed for ruby 1.9, to_sym for ruby 1.8
+          unless (potential_errors = on_calls - ALL_EVENTS).empty?
+            warn "The following are not events: #{potential_errors.join(',')} (class #{self.class})"
+          end
+        end
+
+        # Stops the processing for the current chunk
+        def absorb(*) # Note: the (*) is so that we can alias events like on_meta_data
+          throw :absorb
+        end
+      
+        # Stops the processing of the current source completely.
+        def stop
+          throw :stop
+        end
+
+        def each(&block)
+          return to_enum unless block_given?
+          @block = block
+          catch :stop do
+            super{|chunk| dispatch_chunk(chunk)}
+          end
+        end
+        
+        # Call #dispatch_instead with a list of chunks.
+        # These chunks will not be processed by the current processor
+        # but will be output directly. This stops the processing for
+        # the current chunk.
+        def dispatch_instead(*chunks)
+          chunks.each do |chunk|
+            @block.call chunk
+          end
+          absorb
+        end      
+
+        EVENT_TRIGGER = {
+          :on_header      => :on_chunk,
+          :on_tag         => :on_chunk,
+          :on_audio       => :on_tag,
+          :on_video       => :on_tag,
+          :on_event       => :on_tag,
+          :on_meta_data   => :on_event,
+          :on_cue_point   => :on_event,
+          :on_last_second => :on_event,
+          :on_other_event => :on_event,
+          :on_keyframe    => :on_video,
+          :on_interframe  => :on_video,
+          :on_disposable_interframe => :on_video
+        }.freeze
+      
+        ALL_EVENTS = (EVENT_TRIGGER.keys | EVENT_TRIGGER.values).freeze
+      
+        MAIN_EVENTS = ALL_EVENTS.reject{ |k| EVENT_TRIGGER.has_value?(k)}.freeze
+      
+        EVENT_TRIGGER_LIST = Hash.new{|h, k| h[k] = [k] + h[EVENT_TRIGGER[k]]}.tap{|h| h[nil] = []; h.values_at(*MAIN_EVENTS)}.freeze
+      
+        module ClassMethods
+          # Call give a list of events of #absorb to always absorb chunks of these types.
+          def absorb(*events)
+            events.each{|evt| alias_method evt, :absorb}
+          end
+        end
+        
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+      private
+        def dispatch_chunk(chunk) # :nodoc:
+          evt = chunk.main_event
+          catch :absorb do
+            EVENT_TRIGGER_LIST[evt].each do |event|
+              send(event, chunk) if respond_to?(event)
+            end
+            @block.call chunk
+          end
+        end
+      end #class Base
+
+
+      # We supplement the basic FLV classes with a #main_event method
+      # which returns the most specialize event for that chunk.
+      module MainEvent # :nodoc:
+        module Header
+          def main_event
+            :on_header
+          end
+        end
+
+        module Video
+          MAPPING = {
+            :keyframe => :on_keyframe,
+            :interframe => :on_interframe,
+            :disposable_interframe => :on_disposable_interframe
+          }.freeze
+
+          def main_event
+            MAPPING[frame_type]
+          end
+        end
+
+        module Audio
+          def main_event
+            :on_audio
+          end
+        end
+
+        module Event
+          MAPPING = Hash.new(:on_other_event).merge!(
+            :onMetaData => :on_meta_data,
+            :onCuePoint => :on_cue_point,
+            :onLastSecond => :on_last_second
+          ).freeze
+          def main_event
+            MAPPING[event]
+          end
+        end
+        
+        module Tag
+          def main_event
+            body.main_event
+          end
+        end
+      end #module MainEvent
+    end #module Processor
+  end #module Edit
+  
+  [Header, Tag, Audio, Video, Event].each do |klass|
+    klass.class_eval{ include Edit::Processor::MainEvent.const_get(klass.to_s.sub('FLV::', '')) }
+  end
+  
+end #module FLV

data/lib/flv/edit/processor/filter.rb

@@ -0,0 +1,32 @@
+module FLV
+  module Edit  
+    module Processor
+      
+      # Basic processors can include Filter which
+      # provides a pretty simple #each.
+      # It will call #before_filter then
+      # #filter(chunk) for each chunk.
+      # If #filter returns +:skip+, the chunk won't be yielded
+      # #filter can also stops altogether the processing
+      # of the current source by calling #stop. 
+      module Filter
+        def each
+          return to_enum unless block_given?
+          before_filter
+          catch :stop do
+            super do |chunk|
+              yield chunk unless filter(chunk) == :skip
+            end
+          end
+        end
+      protected
+        def before_filter
+        end
+        def stop
+          throw :stop
+        end
+        
+      end #module Filter
+    end #module Processor
+  end #module Edit
+end #module FLV

data/lib/flv/edit/processor/head.rb

@@ -1,15 +1,19 @@
 module FLV
   module Edit
     module Processor
+
+      # Head is a Processor class (see Base and desc)
       class Head < Base
         desc "Processes only the first NB tags.", :param => {:class => Integer, :name => "NB"}, :shortcut => "n"
-        def on_header(header)
-          @count = self.options[:head]
-        end
 
-        def on_tag(tag)
-          throw :stop if (@count -= 1) < 0
+        def each
+          count = options[:head]
+          super do |chunk|
+            yield chunk
+            break if (count -= 1) < 0 # after the yield because we're not counting the header
+          end
         end
+        
       end
     end
   end

data/lib/flv/edit/processor/join.rb

@@ -2,11 +2,21 @@ module FLV
   module Edit  
     module Processor
 
+      # Join is a Processor class (see Base and desc)
       class Join < Base
-        desc "Join the FLV files"
+        desc "Joins all the inputs together."
+
+        include Dispatcher
     
-        def process_next_file
-          dispatch_chunks(@source) while @source.has_next_file?
+        def each_source_with_join
+          return to_enum(:each_source) unless block_given?
+          yield
+        end
+        alias_method_chain :each_source, :join
+
+        def each(&block)
+          return to_enum unless block_given?
+          each_source_without_join { super }
         end
 
         def on_tag(tag)

data/lib/flv/edit/processor/meta_data_maker.rb

@@ -1,7 +1,11 @@
 module FLV
   module Edit
     module Processor
-      class MetaDataMaker < Base        
+      # MetaDataMaker is a Processor class (see Base) that computes the metadata
+      # for its sources. The metadata for the current source is accessible with #meta_data
+      # It is used by Update.
+      class MetaDataMaker < Base
+        include Dispatcher        
         CHUNK_LENGTH_SIZE = 4 # todo: calc instead?
         TAG_HEADER_SIZE = 11 # todo: calc instead?
         TOTAL_EXTRA_SIZE_PER_TAG = CHUNK_LENGTH_SIZE + TAG_HEADER_SIZE

data/lib/flv/edit/processor/print.rb

@@ -2,10 +2,18 @@ require_relative "printer"
 module FLV
   module Edit
     module Processor
+
+      # Print is a Processor class (see Base and desc)
       class Print < Base
-        desc "Prints out meta data to stdout"
-        def on_meta_data(tag)
-          tag.debug(Printer.new(stdout))
+        desc "Prints out the meta data"
+        include Filter
+        
+        def before_filter
+          @printer = Printer.new(options[:out])
+        end
+
+        def filter(tag)
+          tag.debug(@printer) if tag.is? :onMetaData
         end
       end
     end

data/lib/flv/edit/processor/printer.rb

@@ -2,6 +2,7 @@ module FLV
   module Edit  
     module Processor
       
+      # Printer is a small utility class to print out FLV chunks.
       class Printer
         def initialize(io, options={})
           @io = io

data/lib/flv/edit/processor/reader.rb

@@ -1,29 +1,34 @@
 module FLV
   module Edit  
     module Processor
+
+      # Reader is a Processor class (see Base) which use <tt>options[:files]</tt> to generate
+      # its sources (instead of the passed +source+ which should be nil)
       class Reader < Base
         def initialize(*)
           super
+          raise "Invalid filenames: #{options[:files].inspect}" unless options[:files].all?
+          raise "Please specify at least one filename" if options[:files].empty?
+          raise NotImplemented, "Reader can't have a source (other than options[:files])" if source
           rewind
-          raise "Oups, Filenames were #{@options[:files].inspect}" if @options[:files].include? nil
-          raise "Please specify at least one filename" if @options[:files].empty?
         end
 
-        def has_next_file?
-          @to_process > 0
-        end
-  
-        def rewind
-          @to_process = @options[:files].length
+        def each_source
+          return to_enum(:each_source) unless block_given?
+          rewind
+          yield until @sources.empty?
         end
-
-        def process_next_file
-          raise IndexError, "No more filenames to process" unless has_next_file?
-          @to_process -= 1
-          FLV::File.open(@options[:files][-1- @to_process]) do |f|
-            dispatch_chunks(f)
+        
+        def each
+          FLV::File.open(@sources.shift) do |f|
+            @source = f
+            super
           end
         end
+        
+        def rewind
+          @sources = options[:files].dup
+        end
       end
     end
   end

data/lib/flv/edit/processor/save.rb

@@ -1,28 +1,29 @@
 module FLV
   module Edit
     module Processor
+
+      # Save is a Processor class (see Base and desc)
       class Save < Base
         desc "Saves the result to PATH", :param => {:class => String, :name => "PATH"}
-        def process_next_file
+        
+        def each_source
+          return to_enum(:each_source) unless block_given?
+          @out = FLV::File::open(options[:save] || (h.path+".temp"), "w+b")
           super
         ensure
-          if @out
-            @out.close
-            finalpath = @out.path.sub(/\.temp$/, '')
-            FileUtils.mv(@out.path, finalpath) unless finalpath == @out.path
-          end
-        end
-
-        def on_header(h)
-          @out = FLV::File::open(options[:save] || (h.path+".temp"), "w+b")
-          @out << h
+          @out.close
+          finalpath = @out.path.sub(/\.temp$/, '')
+          FileUtils.mv(@out.path, finalpath) unless finalpath == @out.path
         end
         
-        def on_tag(t)
-          @out << t
+        def each
+          return to_enum unless block_given?
+          super do |chunk|
+            @out << chunk
+            yield chunk
+          end
         end
       end
-    
     end
   end
 end

data/lib/flv/edit/processor/update.rb

@@ -3,17 +3,25 @@ require_relative "meta_data_maker"
 module FLV
   module Edit
     module Processor
+
+      # Update is a Processor class (see Base and desc)
       class Update < Base
-        desc "Updates FLV with an onMetaTag event"
+        include Dispatcher
+        desc "Updates FLV with an onMetaTag event containing all the relevant information."
         def initialize(source=nil, options={})
           super
           @meta_data_maker = MetaDataMaker.new(source.dup, options)
         end
       
+      
         def each(&block)
-          @meta_data_maker.each {}
-        ensure  # even if each throws, we better call super otherwise we won't be synchronized anymore!
-          super
+          return to_enum unless block_given?
+          begin
+            @meta_data_maker.each {}
+          ensure  # even if each throws, we better call super otherwise we won't be synchronized anymore!
+            super rescue nil
+            raise if $!
+          end
         end
       
         absorb :on_meta_data, :on_last_second

data/lib/flv/edit/processor.rb

@@ -1,3 +1,3 @@
-%w(base add command_line cut debug head join print reader save update).each do |proc|
+%w(base filter dispatcher add command_line cut debug head join print reader save update).each do |proc|
   require_relative "processor/#{proc}"
 end

data/lib/flv/edit/version.rb

@@ -2,7 +2,7 @@ module FLV
   module Edit
     FILE = ::File.dirname(__FILE__) + '/../../../VERSION.yml'
     
-    class Version < Struct.new(:major, :minor, :patch)
+    class Version < Struct.new(:major, :minor, :patch) # :nodoc:
       def to_s
         "#{major}.#{minor}.#{patch}"
       end

data/lib/flv/file.rb

@@ -1,4 +1,7 @@
 module FLV
+  # FLV::File provide methods to read a FLV file easily.
+  # Interface is similar to ::File, except that #each will
+  # return FLV chunks instead of lines.
   module File
     def each(*arg, &block)
       return super unless arg.empty?

data/lib/flv/header.rb

@@ -31,7 +31,15 @@ module FLV
     
     def debug(format, *)
       format.header("Header", path)
-      format.values(to_h.tap{|h| h.delete(:path)})
+      format.values(to_h.tap{|h| [:path, :timestamp, :body].each{|key| h.delete(key)}})
+    end
+    
+    def timestamp
+      0
+    end
+    
+    def body
+      self
     end
   end
 end

data/lib/flv/packing.rb

@@ -1,7 +1,6 @@
 require 'singleton'
 
 module FLV
-  class Event < Hash ; end
   # FLV files can contain structured data. This modules makes it easy to (un)pack that data.
   # The packing option +flv_value+ can (un)pack any kind of variable.
   # It corresponds to +SCRIPTDATAVALUE+ in the official FLV file format spec.

data/lib/flv.rb

@@ -1,12 +1,9 @@
 require 'rubygems'
 require 'backports'
+require 'packable'
 
-# utilities
+# Base & Utilities
 require_relative 'flv/util/double_check'
-
-# packing of FLV objects:
-require 'packable'
-require_relative 'flv/packing'
 require_relative 'flv/base'
 
 # FLV body of tags
@@ -17,8 +14,11 @@ require_relative 'flv/body'
 
 # FLV chunks (tags & header)
 require_relative 'flv/timestamp'
-require_relative 'flv/tag'
 require_relative 'flv/header'
+require_relative 'flv/tag'
+
+# packing of FLV objects:
+require_relative 'flv/packing'
 
 # finally:
 require_relative 'flv/file'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: flvedit
 version: !ruby/object:Gem::Version 
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors: 
 - "Marc-Andr\xC3\xA9 Lafortune"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-21 00:00:00 -04:00
+date: 2009-04-22 00:00:00 -04:00
 default_executable: flvedit
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,6 +60,8 @@ files:
 - lib/flv/edit/processor/command_line.rb
 - lib/flv/edit/processor/cut.rb
 - lib/flv/edit/processor/debug.rb
+- lib/flv/edit/processor/dispatcher.rb
+- lib/flv/edit/processor/filter.rb
 - lib/flv/edit/processor/head.rb
 - lib/flv/edit/processor/join.rb
 - lib/flv/edit/processor/meta_data_maker.rb