sequencer 1.0.3 → 1.0.5

data/History.txt

@@ -1,6 +1,14 @@
+=== 1.0.5 / 2011-07-07
+
+* Dicking around with testing frameworks that become obsolete is the worst thing ever.
+
+=== 1.0.4 / 2010-10-26
+
+* Add rseqrename binary that batch-renames sequences
+
 === 1.0.3 / 2010-10-26
 
-* Add rseqpad binary that zero-pads filenames
+* Add rseqpad binary that zero-pads sequences
 
 === 1.0.2 / 2010-05-06
 

data/Manifest.txt

@@ -1,9 +1,10 @@
 .autotest
 History.txt
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
 bin/rseqls
 bin/rseqpad
+bin/rseqrename
 lib/sequencer.rb
 test/test_sequencer.rb

data/{README.txt → README.rdoc}

@@ -6,18 +6,34 @@
 
 Simplifies working with image sequences
 
-== FEATURES/PROBLEMS:
+== FEATURES:
 
 * List all sequences in a directory interspersed with other file entries
 * Detect sequence from single file
 
 == SYNOPSIS:
 
-  require "sequencer"
-	s = Sequencer.from_single_file("/RAID/Film/CONFORM.092183.dpx")
-	s.file_count #=> 3201
-	s.gaps? #=> true
-	s.missing_frames #=> 15, somebody was careless
+From the terminal - go to a directory, and then:
+
+   $rseqls
+   
+      Fussball_Shot[1..1, 3..3].sni
+      FinalLichtUitValSec_Shot1.[1..128].jpg
+      Fussball_Shot3_v02.sni
+      FinalLichtUitValSec_Shot1.0001.ifl
+      FinalLichtUitValSec.0001.ifl
+      FinalLichtUitValSec.[1..185].jpg
+    
+You also have <tt>rseqpad</tt> and <tt>rseqrename</tt> :-)
+      
+From code:
+
+    require "sequencer"
+    s = Sequencer.from_single_file("/RAID/Film/CONFORM.092183.dpx")
+    s.file_count #=> 3201
+    s.gaps? #=> true
+    s.missing_frames #=> 15, somebody was careless
+    s.pattern #=> "CONFORM.%06d.dpx", usable with printf right away
 
 == INSTALL:
 

data/Rakefile

@@ -3,10 +3,11 @@ require 'rubygems'
 require 'hoe'
 require File.dirname(__FILE__) + "/lib/sequencer"
 
+Hoe::RUBY_FLAGS.gsub!(/^-w/, '')
 Hoe.spec 'sequencer' do | s |
-  s.version = Sequencer::VERSION
+  s.readme_file   = 'README.rdoc'
+  s.extra_rdoc_files  = FileList['*.rdoc']
   s.developer('Julik Tarkhanov', 'me@julik.nl')
-  s.extra_dev_deps = {"test-spec" => ">=0"}
 end
 
 # vim: syntax=ruby

data/bin/rseqrename

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + "/../lib/sequencer"
+
+one_file, base_pattern = ARGV.shift, ARGV.shift
+Sequencer.from_single_file(one_file).bulk_rename(base_pattern)

data/lib/sequencer.rb

@@ -1,5 +1,5 @@
 module Sequencer
-  VERSION = '1.0.3'
+  VERSION = '1.0.5'
   NUMBERS_AT_END = /(\d+)([^\d]+)?$/
   
   extend self
@@ -30,7 +30,8 @@ module Sequencer
   
   # Detect a Sequence from a single file and return a handle to it
   def from_single_file(path_to_single_file)
-    File.stat(path_to_single_file)
+    #File.stat(path_to_single_file)
+    
     frame_number = path_to_single_file.scan(NUMBERS_AT_END).flatten.shift
     if frame_number =~ /^0/ # Assume that the input is padded and take the glob path
       sequence_via_glob(path_to_single_file)
@@ -86,7 +87,7 @@ module Sequencer
     attr_reader :directory
     
     def initialize(directory, filenames)
-      raise "Can't sequence nothingness" if filenames.empty?
+      raise "Cannot create a Sequence with no files" if filenames.empty?
       @directory, @filenames = directory, natural_sort(filenames)
       @directory.freeze
       @filenames.freeze
@@ -202,9 +203,17 @@ module Sequencer
     end
     
     # Apply a bulk rename
-    def bulk_rename(with_pattern)
-      rename_map = filenames.inject({}) do | filename, map |
+    def bulk_rename(with_pattern, into_directory = nil, &operation)
+      # Check if the pattern includes a number. If it doesnt, add one and the
+      # extension
+      unless with_pattern.include?("%")
+        padz = last_frame_no.to_s.length
+        with_pattern = [with_pattern, ".%0#{padz}d", File.extname(pattern)].join
+      end
+      
+      rename_map = @filenames.inject({}) do | map, filename |
         frame_no = filename.scan(NUMBERS_AT_END).flatten.shift.to_i
+        
         map.merge(filename => (with_pattern % frame_no))
       end
       
@@ -217,15 +226,19 @@ module Sequencer
         raise "This would overwrite old files with the renamed ones (#{error[0..1]}.join(',')..)"
       end
       
-      if (error = (Dir.entries(@directory) % rename_map.values)).any?
+      if (error = (Dir.entries(@directory) & rename_map.values)).any?
         raise "Files that will be created by the rename are already in place (#{error[0..1]}.join(',')..)"
       end
       
+      destination = into_directory || directory
       
-    end
-    
-    def bulk_rename!(with_pattern)
-      replace(bulk_rename(with_pattern))
+      rename_map.each_pair do | from_path, to_path |
+        src, dest = File.join(directory, from_path), File.join(destination, to_path)
+        File.rename(src, dest)
+        #yield(src, dest)
+      end
+      
+      self.class.new(destination, rename_map.values)
     end
     
     private

data/test/test_sequencer.rb

@@ -1,10 +1,9 @@
 require 'test/unit'
-require 'rubygems'
-require 'test/spec'
+require 'set'
 require 'fileutils'
 require File.dirname(__FILE__) + '/../lib/sequencer'
 
-TEST_DIR = File.dirname(__FILE__) + "/tmp"
+TEST_DIR = File.expand_path(File.dirname(__FILE__)) + "/tmp"
 
 def emit_test_dirs
   start_f = 123
@@ -59,131 +58,166 @@ def teardown_test_dirs
   FileUtils.rm_rf(TEST_DIR)
 end
 
-context "Sequencer.glob_and_padding_for should" do
+class Test_glob_and_padding_for < Test::Unit::TestCase
   
-  specify "return proper glob pattern and padding for a path with extension" do
+  def test_returns_proper_glob_pattern_padding_for_a_path_with_extension
     glob, pad = Sequencer.glob_and_padding_for("file.00001.gif")
-    glob.should.equal "file.[0-9][0-9][0-9][0-9][0-9].gif"
-    pad.should.equal 5
+    assert_equal "file.[0-9][0-9][0-9][0-9][0-9].gif", glob
+    assert_equal 5, pad
   end
-
-  specify "return proper glob pattern and padding for a path without extension" do
+  
+  def test_returns_proper_glob_pattern_and_padding_for_a_path_without_extension
     glob, pad = Sequencer.glob_and_padding_for("file.00001")
-    glob.should.equal "file.[0-9][0-9][0-9][0-9][0-9]"
-    pad.should.equal 5
+    assert_equal "file.[0-9][0-9][0-9][0-9][0-9]", glob
+    assert_equal 5, pad
   end
   
-  specify "return nil for a file that is not a sequence" do
+  def return_nil_for_a_file_that_is_not_in_the_sequence
      glob, pad = Sequencer.glob_and_padding_for("file")
-     glob.should.be.nil
+     assert_nil glob
   end
 end
 
-context "Sequencer.entries should" do
-  before { emit_test_dirs }
-  after { teardown_test_dirs }
-  specify "return entries for every sequence in a directory" do
+class Sequencer_entries_should < Test::Unit::TestCase
+  def setup; emit_test_dirs; end
+  def teardown; teardown_test_dirs; end
+  
+  def test_returns_entries_for_every_sequence_in_a_directory
     entries = Sequencer.entries(TEST_DIR + "/many_seqs")
+    flunk "this test is not finished"
   end
 end
 
-context "A Sequence created from unpadded files should" do
-  before { emit_test_dirs }
-  after { teardown_test_dirs }
+class A_Sequence_created_from_unpadded_files_should < Test::Unit::TestCase
+  def setup; emit_test_dirs; end
+  def teardown; teardown_test_dirs; end
   
-  specify "be properly created" do
+  def test_properly_created
     s = Sequencer.from_single_file(TEST_DIR + "/natural_numbering/somefiles 5545168.png")
-    s.should.not.be.nil
-    s.expected_frames.should.equal 30
-    s.file_count.should.equal 30
-    s.pattern.should.equal "somefiles %07d.png"
+    assert_not_nil s
+    assert_equal 30, s.expected_frames
+    assert_equal 30, s.file_count
+    assert_equal "somefiles %07d.png", s.pattern
+  end
+end
+
+class A_Sequence_created_from_a_file_that_has_no_numbering_slot_should
+  def setup; @single = Sequencer::Sequence.new("/tmp", ["foo.tif"]); end
+  
+  def test_report_a_pattern_that_is_the_name_as_filename
+    assert_equal 'foo.tif', @single.pattern
+    assert @single.single_file?
+    assert_equal 1, @single.expected_frames
+    assert_equal "#<foo.tif>", @single.inspect
   end
 end
 
-context "A Sequence created from a file that has no numbering slot should" do
-  before { @single = Sequencer::Sequence.new("/tmp", ["foo.tif"]) }
+class Sequencer_bulk_rename_should < Test::Unit::TestCase
+  def setup
+    emit_test_dirs
+    @with_gaps = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/broken_seq.000245.tif")
+  end
+  
+  def teardown
+    teardown_test_dirs
+  end
   
-  specify "report a pattern that is the same as filename" do
-    @single.pattern.should.equal "foo.tif"
-    @single.should.be.single_file?
-    @single.expected_frames.should.equal 1
-    @single.inspect.should.equal "#<foo.tif>"
+  def test_return_a_new_Sequencer_with_right_parameters
+    res = @with_gaps.bulk_rename("another_base")
+    assert_equal @with_gaps.length, res.length
+    assert_equal @with_gaps.directory, res.directory
+    assert_equal "another_base.%03d.tif", res.pattern
+    
+    assert File.exist?(res.to_paths[0])
+    assert File.exist?(res.to_paths[-1])
   end
 end
 
-context "A Sequence created from pad-numbered files should" do
-  before do
+class A_Sequence_created_from_pad_numbered_files_should < Test::Unit::TestCase
+  def setup
     emit_test_dirs
     @gapless = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/seq1.000245.tif")
     @with_gaps = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/broken_seq.000245.tif")
     @single = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/single_file.002123154.tif")
   end
   
-  after { teardown_test_dirs }
+  def teardown
+    teardown_test_dirs
+  end
   
-  specify "initialize itself from one path to a file in the sequence without gaps" do
-    @gapless.should.not.be.nil
-    @gapless.should.be.kind_of(Sequencer::Sequence)
-    @gapless.should.respond_to(:gaps?)
-    @gapless.should.not.be.single_file?
+  def test_initialize_itself_from_one_path_to_a_file_in_the_sequence_without_gaps
+    assert_not_nil @gapless
+    assert_kind_of Sequencer::Sequence, @gapless
+    assert_respond_to @gapless, :gaps?
+    assert !@gapless.single_file?
     
-    @gapless.should.blaming("this is a gapless sequence").not.be.gaps?
-    @gapless.file_count.should.blaming("actual file count in sequence").equal(446)
-    @gapless.length.should.blaming("actual file count in sequence").equal(446)
-    @gapless.expected_frames.should.blaming("expected frame count in sequence").equal(446)
-    @gapless.inspect.should.blaming("inspect itself").equal('#<seq1.[123..568].tif>')
-    @gapless.pattern.should.equal 'seq1.%06d.tif'
+    assert !@gapless.gaps?, "this is a gapless sequence"
+    assert_equal 446, @gapless.file_count, "actual file count in sequence"
+    assert_equal 446, @gapless.length, "actual file count in sequence"
+    assert_equal 446, @gapless.expected_frames, "expected frame count in sequence"
+    assert_equal '#<seq1.[123..568].tif>', @gapless.inspect
     
     files = @gapless.to_a
-    files.length.should.equal 446
-    files[0].should.equal 'seq1.000123.tif'
+    assert_equal 446, files.length
+    assert_equal 'seq1.000123.tif', files[0] 
     
     paths = @gapless.to_paths
-    paths.length.should.equal 446
-    paths[0].should.equal(File.dirname(__FILE__) + "/tmp/sequence_and_sole_file/seq1.000123.tif")
+    assert_equal 446, paths.length
+    assert_equal File.expand_path(File.dirname(__FILE__)) + "/tmp/sequence_and_sole_file/seq1.000123.tif", paths[0]
   end
   
-  specify "initialize itself from one path to a file in the sequence with gaps" do
-    @with_gaps.should.not.be.nil
-    @with_gaps.should.be.kind_of(Sequencer::Sequence)
-    @with_gaps.should.not.be.single_file?
+  def test_initialize_itself_from_one_path_to_a_file_in_the_sequence_with_gaps
+    assert_not_nil @with_gaps
+    assert_kind_of Sequencer::Sequence, @with_gaps
+    assert !@with_gaps.single_file?
     
-    @with_gaps.should.be.gaps?
-    @with_gaps.gap_count.should.equal 1
-    @with_gaps.segment_count.should.equal 2
-    @with_gaps.missing_frames.should.equal(9)
-    @with_gaps.inspect.should.blaming("inspect itself").equal('#<broken_seq.[123..568, 578..702].tif>')
-    @with_gaps.should.include("broken_seq.000123.tif")
-    @with_gaps.should.not.include("bogus.123.tif")
+    assert @with_gaps.gaps?
+    assert_equal 1, @with_gaps.gap_count
+    assert_equal 2, @with_gaps.segment_count
+    assert_equal 9, @with_gaps.missing_frames
+    assert_equal '#<broken_seq.[123..568, 578..702].tif>', @with_gaps.inspect
+    assert @with_gaps.include?("broken_seq.000123.tif")
+    assert !@with_gaps.include?("bogus.123.tif")
   end
   
-  specify "return subsequences without gaps" do
+  def test_return_subsequences_without_gaps
     subseqs = @with_gaps.to_sequences
-    subseqs[0].should.be.kind_of(Sequencer::Sequence)
-    subseqs[1].should.be.kind_of(Sequencer::Sequence)
+    assert_kind_of Sequencer::Sequence, subseqs[0]
+    assert_kind_of Sequencer::Sequence, subseqs[1]
     
     first_seq, second_seq = subseqs
-    first_seq.first_frame_no.should.equal 123
-    first_seq.last_frame_no.should.equal 568
-    second_seq.first_frame_no.should.equal 578
-    second_seq.last_frame_no.should.equal 702
+    assert_equal 123, first_seq.first_frame_no
+    assert_equal 568, first_seq.last_frame_no
+    assert_equal 578, second_seq.first_frame_no
+    assert_equal 702, second_seq.last_frame_no
     
-    first_seq.directory.should.equal second_seq.directory
-    first_seq.directory.should.equal @with_gaps.directory
+    assert_equal second_seq.directory, first_seq.directory
+    assert_equal @with_gaps.directory, first_seq.directory 
   end
   
-  specify "list all sequences in directory and subdirectories using the pattern" do
+  def test_list_all_sequences_in_directory_and_subdirectories_using_the_pattern
     s = Sequencer.from_glob(TEST_DIR + "/**/*.tif")
-    inspected = '[#<single.tif>, #<seq1.[458..512].tif>, #<anotherS [228..312].tif>, #<in_subdir [445..471].tif>, #<seq1.[123..568].tif>, #<somefile.tif>, #<single_file.002123154.tif>, #<broken_seq.[123..568, 578..702].tif>]'
-    s.inspect.should.equal inspected
-  end
-  
-  specify "initialize itself from a single file" do
-    @single.should.be.single_file?
-    @single.inspect.should.equal '#<single_file.002123154.tif>'
-    @single.should.not.be.gaps?
-    @single.expected_frames.should.equal 1
-    @single.file_count.should.equal 1
+    # Here we need to use a Set since Ruby does not
+    ref_set = Set.new([
+      "#<anotherS [228..312].tif>",
+      "#<seq1.[458..512].tif>",
+      "#<single.tif>",
+      "#<in_subdir [445..471].tif>",
+      "#<broken_seq.[123..568, 578..702].tif>",
+      "#<seq1.[123..568].tif>",
+      "#<single_file.002123154.tif>",
+      "#<somefile.tif>"
+    ])
+    output_sequences = Set.new(s.map{|sequence| sequence.inspect })
+    assert_equal ref_set, output_sequences
+  end
+  
+  def test_initialize_itself_from_a_single_file
+    assert @single.single_file?
+    assert_equal '#<single_file.002123154.tif>', @single.inspect 
+    assert !@single.gaps?
+    assert_equal 1, @single.expected_frames
+    assert_equal 1, @single.file_count
   end
   
 end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: sequencer
 version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 3
-  version: 1.0.3
+  prerelease: 
+  version: 1.0.5
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -15,61 +10,45 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-26 00:00:00 +02:00
+date: 2011-07-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: test-spec
+  name: hoe
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+        version: "2.10"
   type: :development
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 2
-        - 6
-        - 1
-        version: 2.6.1
-  type: :development
-  version_requirements: *id002
 description: Simplifies working with image sequences
 email: 
 - me@julik.nl
 executables: 
 - rseqls
 - rseqpad
+- rseqrename
 extensions: []
 
 extra_rdoc_files: 
 - History.txt
 - Manifest.txt
-- README.txt
+- README.rdoc
 files: 
 - .autotest
 - History.txt
 - Manifest.txt
-- README.txt
+- README.rdoc
 - Rakefile
 - bin/rseqls
 - bin/rseqpad
+- bin/rseqrename
 - lib/sequencer.rb
 - test/test_sequencer.rb
+- .gemtest
 has_rdoc: true
 homepage: http://guerilla-di.org/sequencer
 licenses: []
@@ -77,7 +56,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -85,23 +64,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: sequencer
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Simplifies working with image sequences