gf-dircat 0.0.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 gf
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,44 @@
+= DIRCAT: Utilities per la gestione di cataloghi e di directory
+
+== dircat_build
+
+Costruisce un catalogo a partire da una directory
+
+Esempio:
+
+Per costruire un catalogo di una directory dir1
+
+DirCatBuild -o nome catalogo dir1
+
+== dircat_cfr
+
+Confronta due cataloghi
+
+== dircat_cmp
+
+== dircat_query
+
+Interroga un catalogo
+
+== DESCRIPTION:
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* utilizza la libreria abstract di kwartz
+* gui: dipende da fxruby e/o wxruby
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== Copyright
+
+Copyright (c) 2009 gf. See LICENSE for details.

data/bin/dircat-build.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..") )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+
+require 'dircat/cli/dircat_build.rb'
+
+DirCatBuild.run

data/bin/dircat-cfr.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..") )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+
+require 'dircat/cli/dircat_cfr.rb'
+
+DirCatCfr.run

data/bin/dircat-cmp.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..") )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+
+require 'dircat/cli/dircat_cmp.rb'
+
+DirCatCmp.run

data/bin/dircat-query.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..") )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+
+require 'dircat/cli/dircat_query.rb'
+
+DirCatQuery.run

data/lib/dircat/cli/dircat_build.rb

@@ -0,0 +1,105 @@
+# stdlib
+require 'optparse'
+
+# dircat
+require 'dircat/dircat.rb'
+
+#
+# Build a catalogue starting from a directory
+#
+class DirCatBuild
+
+  def self.run
+    self.new.parse_args( ARGV )
+  end
+
+  def parse_args( argv )
+    options = { :verbose => true, :force => false }
+    opts = OptionParser.new
+    opts.banner << "Usage: dircat_build [options]\n"
+    opts.banner << "\n"
+    opts.banner << "Build a catalogue starting from a directory\n";
+    opts.banner << "\n"
+
+    opts.on("-h", "--help", "Print this message") do
+      puts opts
+      return
+    end
+
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+
+    opts.on("-q", "--quiet", "quiet mode as --no-verbose") do |v|
+      options[:verbose] = false
+    end
+
+    opts.on("-f", "--force", "force write on existent file") do |v|
+    	options[:force] = true
+    end
+
+    opts.on("-o [FILE]", "--output [FILE]",String) do |v|
+      options[:output] = v
+    end
+
+    rest = opts.parse(argv)
+
+    # p options
+    # p ARGV
+
+    if rest.length < 1
+      puts "inserire il nome della directory di cui creare il catalogo"
+      puts "-h to print help"
+      return
+    end
+
+    dirname = rest[0]
+    dirname = File.expand_path( dirname )
+    if not FileTest.directory?(dirname)
+      puts "directory "#{dirname} not exists or is not a directory"
+      return 
+    end
+
+    #
+    # option verbose
+    #
+
+    if options.has_key?(:verbose)
+      if options[:verbose]
+        $VERBOSE_LEVEL = 1
+      end
+    end
+
+    #
+    # option: output, force
+    #
+    output = $stdout
+    if options.has_key?(:output)
+      if options[:output]
+    	  filename = options[:output]
+    	else
+    	  filename = "cat_" + File.basename( dirname ) + "_" + Date.today.strftime("%Y%m%d") + ".yaml"
+      end
+      if File.exist?(filename) and not options[:force]
+        puts "File #{filename} exists use --force or -f to overwrite"
+        return
+      end
+      output = File.open(filename, "w")
+    end
+
+    start_datetime = DateTime.now
+    s = DirCat.loadfromdir(dirname)
+    end_datetime = DateTime.now
+
+    # s.pr
+    # f.puts s.to_yaml
+    s.savetofile( output )
+
+    if output != $stdout
+      output.close
+    end
+    $stderr.puts s.report
+    $stderr.puts "tempo: #{end_datetime - start_datetime}"
+  end
+
+end

data/lib/dircat/cli/dircat_cfr.rb

@@ -0,0 +1,69 @@
+# stdlib
+require 'optparse'
+
+# dircat
+require 'dircat/dircat.rb'
+
+#
+#
+#
+class DirCatCfr
+
+  def self.run
+    self.new.parse_args( ARGV )
+  end
+
+  def parse_args( args )
+    options = {}
+    opts = OptionParser.new
+    opts.banner =
+        "Usage: dircat_cfr.rb [options] <filedircat1> <filedircat2>\n\n" +
+        "fa la differenza fra il primo catalog e il secondo\n" +
+        "<filedircat1> - <filedircat2>\n" +
+        "e stampa sull'output con un formato\n"
+
+    opts.on("-h", "--help", "Print this message") do
+      puts opts
+      return
+    end
+
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+
+    opts.on("-f FORMAT", "--fmt FORMAT", "formato") do |v|
+      options[:fmt] = v
+    end
+    rest = opts.parse( args )
+
+    # p options
+    # p ARGV
+
+    if rest.length < 2
+      puts "inserire il nome di due cataloghi da confrontare"
+      puts "dircat_cfr -h to print help"
+      exit
+    end
+
+    cat_filename1 = rest[0]
+    cat_filename2 = rest[1]
+
+    puts "build first set"
+    s1 = DirCat.loadfromfile(cat_filename1)
+
+    puts "build second set"
+    s2 = DirCat.loadfromfile(cat_filename2)
+
+    puts "build difference"
+    s3 = s1 - s2
+
+    case options[:fmt]
+    when "simple"
+      s3.fmt_simple
+    when "ruby"
+      s3.fmt_ruby( "." )
+    else
+      s3.fmt_simple
+    end
+  end
+end

data/lib/dircat/cli/dircat_cmp.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+require 'dircat/dircat.rb'
+
+#
+# MAIN
+#
+
+class DirCatCmp
+
+  def self.run
+    self.new.parse_args( ARGV )
+  end
+
+  def parse_args(args)
+    options = {}
+    opts = OptionParser.new
+    opts.banner = "Usage: example.rb [options]"
+
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+    rest = opts.parse( args )
+
+    # p options
+    # p ARGV
+
+    if rest.length < 1
+      puts "inserire il nome di due directory da confrontare"
+      return
+    end
+
+    dirname1 = rest[0]
+    dirname2 = rest[1] if rest[1]
+
+    if dirname2
+      twoset( dirname1, dirname2 )
+      return
+    end
+
+    if dirname1
+      oneset( dirname1 )
+      return
+    end
+  end
+
+  def oneset( dirname )
+    puts "build set"
+    s = DirCat.loadfromdir(dirname)
+    # s.pr
+    puts s.to_yaml
+  end
+
+  def twoset( dirname1, dirname2 )
+    puts "build first set"
+    s1 = DirCat.loadfromdir(dirname1)
+
+    puts "build second set"
+    s2 = DirCat.loadfromdir(dirname2)
+
+    puts "build difference"
+    s3 = s1 - s2
+
+    s3.pr
+  end
+end

data/lib/dircat/cli/dircat_query.rb

@@ -0,0 +1,59 @@
+require 'optparse'
+require 'dircat/dircat.rb'
+
+#
+# DirCatQuery
+#
+class DirCatQuery
+
+  def self.run
+    self.new.parse_args( ARGV)
+  end
+
+  def parse_args( args )
+    options = {}
+    opts = OptionParser.new
+    opts.banner =
+      "Usage: dircat_query [options] <filedircat> <command>\n" +
+      "mostra informazioni su un dircat\n"
+
+    opts.on("-h", "--help", "Print this message") do
+      puts opts
+      return
+    end
+
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+
+    rest = opts.parse( args )
+
+    # p options
+    # p ARGV
+
+    if rest.length < 2
+      puts "inserire il nome del catalogo da interrogare e il comando da eseguire"
+      puts "-h to print help"
+      return
+    end
+
+    cat_filename = rest[0]
+    command = rest[1]
+
+    #
+    # option verbose
+    #
+    if options.has_key?(:verbose)
+      if options[:verbose]
+        $VERBOSE_LEVEL = 1
+      end
+    end
+
+    s = DirCat.loadfromfile( cat_filename )
+
+    #case command
+    #else
+      puts s.send( command.to_sym )
+    #end
+  end
+end

data/lib/dircat/dircat.rb

@@ -0,0 +1,263 @@
+# stdlib
+require 'fileutils'
+require 'tmpdir'
+require 'yaml'
+require 'ostruct'
+
+# dircat
+require 'rubygems'
+require 'gf_utility/md5'
+require 'gf_utility/numeric'
+
+#
+# GLOBAL VAR
+#
+
+$VERBOSE_LEVEL = 0
+
+class EntrySer < OpenStruct
+end
+
+#
+# Entry
+#
+class Entry
+
+  attr_reader :md5
+  attr_reader :name
+  attr_reader :path
+  attr_reader :size
+  attr_reader :mtime
+
+  def from_filename( filename )
+    # puts "Entry::initialize #f"
+    if $VERBOSE_LEVEL > 0
+      cr = "\r"
+      clear = "\e[K"
+      print "#{cr}#{filename}#{clear}"
+    end
+    @name = File.basename(filename)
+    @path = File.dirname(filename)
+    stat = File.stat(filename)
+    @size = stat.size
+    @mtime = stat.mtime
+    # self.md5 = Digest::MD5.hexdigest(File.read( f ))
+    @md5 = MD5.file( filename ).hexdigest
+    self
+  end
+
+  def from_ser( entry_ser )
+    @md5   = entry_ser.md5
+    @name  = entry_ser.name
+    @path  = entry_ser.path
+    @size  = entry_ser.size
+    @mtime = entry_ser.mtime
+    self
+  end
+
+  def to_ser
+    entry_ser = EntrySer.new
+    entry_ser.md5   = @md5
+    entry_ser.name  = @name
+    entry_ser.path  = @path
+    entry_ser.size  = @size
+    entry_ser.mtime = @mtime
+    entry_ser
+  end
+
+  def to_s
+    @md5 + "  " + @name + "\t " + @path + "\n"
+  end
+
+end
+
+class DirCatSer < OpenStruct
+end
+
+
+class DirCatException < RuntimeError
+
+end
+
+#
+# DirCat
+#
+class DirCat
+
+  attr_reader :dirname
+  # data di creazione
+  attr_reader :ctime
+  attr_writer :ctime
+  # attr_reader :entries
+
+  def from_dirname( dirname )
+    # puts "#{self.class.name}#initialize"
+    @dirname = dirname
+    @ctime = DateTime.now
+    @entries = Array.new
+    @md5ToEntries = Hash.new
+    self
+  end
+
+  def from_ser( dircat_ser )
+    @dirname = dircat_ser.dirname
+    @ctime   = dircat_ser.ctime
+    @entries = Array.new
+    @md5ToEntries = Hash.new
+    dircat_ser.entries.each{ |entry_ser|
+      add_entry( Entry.new.from_ser( entry_ser ) )
+    }
+    self
+  end
+
+  def to_ser
+    dircat_ser = DirCatSer.new
+    dircat_ser.version = 0.1
+    dircat_ser.dirname = @dirname
+    dircat_ser.ctime   = @ctime
+    dircat_ser.entries = []
+    @entries.each { |entry|
+      dircat_ser.entries << entry.to_ser
+    }
+    dircat_ser
+  end
+
+  def self.loadfromdir( dirname )
+    # puts "#{self.class.name}#loadfromdir( #{dirname} )"
+    if not File.directory?( dirname )
+      raise "'#{dirname}' non e' una directory o non esiste"
+    end
+
+    s = self.new
+    s.from_dirname( File.expand_path( dirname ) )
+    s._loadfromdir
+  end
+
+  def _loadfromdir()
+    old_dirname = Dir.pwd
+    Dir.chdir( @dirname )
+    Dir["**/*"].each { |f|
+      # puts "#{self.class.name}#loadfromdir #{f}"
+      next if File.directory?( f )
+      add_entry( Entry.new.from_filename( f ) )
+    }
+    if $VERBOSE_LEVEL > 0
+      print "\n"
+    end
+    Dir.chdir( old_dirname )
+    self
+  end
+
+  def self.loadfromfile( filename )
+    if not File.exist?( filename )
+      raise DirCatException.new, "'#{filename}' not exists"
+    end
+    dircat_ser = YAML::load( File.open( filename ) )
+    DirCat.new.from_ser( dircat_ser )
+  end
+
+  def savetofile( file )
+    if file.kind_of?(String)
+      begin
+        File.open( file, "w" ) do |f|
+          f.puts to_ser.to_yaml
+        end
+      rescue Errno::ENOENT
+        raise DirCatException.new, "DirCat: cannot write into '#{file}'", caller
+      end
+    else
+      file.puts to_ser.to_yaml
+    end
+  end
+
+  def size
+    @entries.size
+  end
+
+  def bytes
+    @entries.inject(0) {|sum, entry| sum + entry.size }
+  end
+
+  def report
+    dups = duplicates
+    s = "Directory base: #@dirname\n" +
+      "Nr. file #{size}\n" +
+      "Bytes #{bytes.with_separator}"
+    if duplicates.size > 0
+      s+= "\n duplicates #{dups.size}"
+    end
+    s
+  end
+
+  def add_entry( e )
+    @entries.push( e )
+    if @md5ToEntries.has_key?( e.md5 )
+      # puts "Entry duplicata!!!"
+      @md5ToEntries[ e.md5 ].push( e )
+    else
+      @md5ToEntries[ e.md5 ] = [ e ]
+    end
+  end
+
+  def contains( e )
+    @md5ToEntries.has_key?( e.md5 )
+  end
+
+  def -(s)
+    result = DirCat.new.from_dirname( @dirname )
+    @entries.each { |e|
+      result.add_entry(e) unless s.contains(e)
+    }
+    result
+  end
+
+  def duplicates
+    list = []
+    @md5ToEntries.each_value do |ee|
+      next if ee.size < 2
+      list.push( ee )
+    end
+    list
+  end
+
+  def fmt_simple
+    @entries.each { |e|
+      print e.to_s
+    }
+  end
+
+  def fmt_ruby( dst )
+    puts "require 'fileutils'"
+    @entries.each { |entry|
+      src = File.join( @dirname, entry.path, entry.name );
+      puts "FileUtils.cp( \"#{src}\", \"#{dst}\" )"
+    }
+  end
+
+  def list_dup
+    r = ""
+    duplicates.flatten.each { |e|
+      r += e.to_s + "\n"
+    }
+    r
+  end
+
+  def script_dup
+    r = "require 'fileutils'\n"
+    duplicates.each { |entries|
+      flg_first = true
+      r += "\n"
+      entries.each{ |entry|
+        src = File.join( @dirname, entry.path, entry.name );
+        if flg_first
+          flg_first = false
+          r += "# FileUtils.mv( \"#{src}\", \"#{Dir.tmpdir}\" )\n"
+        else
+          r += "FileUtils.mv( \"#{src}\", \"#{Dir.tmpdir}\" )\n"
+        end
+      }
+    }
+    r
+  end
+
+end

data/lib/dircat.rb

@@ -0,0 +1,3 @@
+class Dircat
+  VERSION = '0.0.1'
+end

data/test/dircat/tc_dircat.rb

@@ -0,0 +1,81 @@
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", "..") )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+
+require 'test/unit'
+require 'dircat/dircat.rb'
+
+# dir1 contiene 2 file
+# aggiunto un file a dir1
+# dir2 contiene 3 file (uno in piu' di dir2)
+
+# dir 3 contiene file duplicati
+
+#
+# data/
+# |-- dir1
+# |   |-- file1.txt
+# |   |-- file2.txt
+# |   `-- subdir
+# |       `-- file3.txt
+# `-- dir2
+#     |-- file1.txt
+#     `-- subdir
+#         `-- file3.txt
+
+
+class TC_DirCat < Test::Unit::TestCase
+
+  def setup
+    @data_dir = File.join($DIRCAT_HOME, "test", "dircat", "data")
+    @tmp_dir  = File.join( @data_dir, "tmp" )
+  end
+
+  def teardown
+  end
+
+  def test_dircat1
+    dircat1 = DirCat.loadfromdir( File.join(@data_dir, "dir1") )
+    assert_equal(2, dircat1.size )
+    assert_equal(4, dircat1.bytes )
+  end
+
+  def test_dircat2
+    dircat2 = DirCat.loadfromdir( File.join(@data_dir, "dir2") )
+    assert_equal(3, dircat2.size )
+    assert_equal(6, dircat2.bytes )
+  end
+
+  def test_diff_dir1_dir2
+    dircat1 = DirCat.loadfromdir( File.join(@data_dir, "dir1") )
+    dircat2 = DirCat.loadfromdir( File.join(@data_dir, "dir2") )
+    # dir1 contiene tutti i file di dir2
+    cat_diff = dircat1 - dircat2
+    assert_equal(0, cat_diff.size)
+  end
+
+  def test_diff_dir2_dir1
+    dircat1 = DirCat.loadfromdir( File.join(@data_dir, "dir1") )
+    dircat2 = DirCat.loadfromdir( File.join(@data_dir, "dir2") )
+
+    # dir2 contiene un file in piu' di dir1
+    cat_diff = dircat2 - dircat1
+    assert_equal(1, cat_diff.size)
+  end
+
+  def test_dir1_ser
+    dircat1  = DirCat.loadfromdir( File.join(@data_dir, "dir1") )
+    not_existent_file = File.join(@tmp_dir, "not_existent", "dircat1.yaml")
+    tmp_file = File.join(@tmp_dir, "dircat1.yaml")
+
+    assert_raise DirCatException do
+      dircat1.savetofile( not_existent_file )
+    end
+
+    dircat1.savetofile( tmp_file )
+
+    dircat1_bis = DirCat.loadfromfile( tmp_file )
+    assert_equal( 0, (dircat1 - dircat1_bis).size )
+    assert_equal( 0, (dircat1_bis - dircat1).size )
+  end
+
+end

data/test/dircat/tc_dircat_build.rb

@@ -0,0 +1,41 @@
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), "..", "..") )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+
+# stdlib
+require 'test/unit'
+
+# dircat
+require 'dircat/dircat.rb'
+require 'dircat/cli/dircat_build.rb'
+
+class TC_DirCatBuild < Test::Unit::TestCase
+
+  def setup
+    @testdata_dirname         = File.join( $DIRCAT_HOME, "test", "dircat", "data")
+    @dir1_dirname             = File.join( @testdata_dirname, "dir1" )
+    @dir2_dirname             = File.join( @testdata_dirname, "dir2" )
+    @certified_output_dirname = File.join( @testdata_dirname, "certified_output" )
+    @tmp_output_dirname       = File.join( @testdata_dirname, "tmp" )
+  end
+
+  def test_help
+    args = "-h"
+    DirCatBuild.new.parse_args( args.split )
+  end
+
+  def test_dir1
+    expect_filename = File.join( @certified_output_dirname, "dircat1.yaml" )
+    result_filename = File.join( @tmp_output_dirname,       "dircat1.yaml")
+    args = "-f -o #{result_filename} #{@dir1_dirname}"
+    DirCatBuild.new.parse_args( args.split )
+
+    cat_expect = DirCat.loadfromfile( expect_filename )
+    cat_result = DirCat.loadfromfile( result_filename )
+
+    assert_equal( 0, (cat_result - cat_result).size )
+
+    assert_equal( 0, (cat_result - cat_expect).size )
+    assert_equal( 0, (cat_expect - cat_result).size )
+  end
+
+end

data/test/test_dircat.rb

@@ -0,0 +1,6 @@
+$DIRCAT_HOME = File.expand_path( File.join( File.dirname( __FILE__), ".." ) )
+$:.unshift( File.join($DIRCAT_HOME, "lib" ) )
+$:.unshift( File.join($DIRCAT_HOME, "test" ) )
+
+require 'dircat/tc_dircat.rb'
+require 'dircat/tc_dircat_build.rb'

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: gf-dircat
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- gf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tree_visitor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: giovanni.ferro@gmail.com
+executables: 
+- dircat-cfr.rb
+- dircat-query.rb
+- dircat-cmp.rb
+- dircat-build.rb
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- lib/dircat.rb
+- lib/dircat/cli/dircat_build.rb
+- lib/dircat/cli/dircat_cfr.rb
+- lib/dircat/cli/dircat_cmp.rb
+- lib/dircat/cli/dircat_query.rb
+- lib/dircat/dircat.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/gf/tree_visitor
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ralbum
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/dircat/tc_dircat.rb
+- test/dircat/tc_dircat_build.rb
+- test/test_dircat.rb