d8a 0.0.1

data/lib/d8a/cached8a.rb

@@ -0,0 +1,124 @@
+require 'yaml'
+
+module CacheD8a
+  # <d8m> -> { <attr> => <value>... }
+  attr_accessor :cache
+
+
+  def CacheD8a.extended(d8a)
+    # Set up new attributes
+    #d8a.attrs.push(:cached)
+
+    # load existing .d8acache 
+    begin
+      yaml = ""
+      d8a.read(".d8acache") { |f|
+        while s = f.read(10000)
+          yaml += s
+        end
+      }
+      d8a.cache = YAML.load(yaml)
+    rescue Errno::ENOENT
+      d8a.cache = {}
+    end
+
+
+    # wrap methods
+    class << d8a
+      # use cached attrs when possible
+      alias_method :__cached8a_ref, :[]
+      def [](d8m, attr = nil)
+        cached = cache_entry(d8m)
+
+        if cached
+          attr ? cached[attr] : cached
+
+        elsif attr
+          __cached8a_ref(d8m, attr)
+
+        elsif d8m =~ /.d8acache$/
+          __cached8a_ref(d8m)
+
+        else
+          @cache[d8m] = __cached8a_ref(d8m)
+        end
+      end
+
+
+      # update cache entry after []=
+      alias_method :__cached8a_refeq, :[]=
+      def []=(d8m, attr, val = nil)
+        result = __cached8a_refeq(d8m, attr, val)
+        @cache[d8m][attr] = val if @cache.has_key?(d8m) && ! attr.is_a?(Hash)
+        result
+      end
+
+
+      # don't show .d8acache on each
+      alias_method :__cached8a_each, :each
+      def each
+        __cached8a_each do |d8m|
+          yield d8m unless d8m =~ /.d8acache$/
+        end
+      end
+
+
+      # refresh cache entry after write
+      alias_method :__cached8a_write, :write
+      def write(d8m, &block)
+        @cache.delete(d8m)
+        result = __cached8a_write(d8m, &block)
+        self[d8m]   # re-cache values
+        result
+      end
+
+
+      # clear cache entry after delete
+      alias_method :__cached8a_delete, :delete
+      def delete(d8m)
+        @cache.delete(d8m)
+        __cached8a_delete(d8m)
+      end
+
+
+      # rewrite .d8acache on flush
+      alias_method :__cached8a_flush, :flush
+      def flush
+        __cached8a_write(".d8acache") do |f|
+          f.write(YAML.dump(@cache))
+        end
+        __cached8a_flush
+      end
+    end
+  end
+
+
+  # return cached data, deleting any invalid entries and optionally
+  # creating missing entries
+  def cache_entry(d8m)
+    @cache.delete(d8m) if @cache[d8m] &&
+      @id_attrs.any? { |attr| @cache[d8m][attr] != __send__(attr, d8m) }
+    @cache[d8m]
+  end
+  private :cache_entry
+
+
+  # defines a new synthetic attribute that exists only in the cache
+  def synthetic_attr(*new_attrs)
+    new_attrs.each do |new_attr|
+      instance_eval %Q!
+        class << self
+          def #{new_attr.to_s}(d8m, d8m_attrs = nil)
+            cached = cache_entry(d8m)
+            cached ? cached[#{new_attr.to_s}] : nil
+          end
+
+          def #{new_attr.to_s}=(d8m, val)
+            self[d8m]   # populate cache
+            @cache[d8m][#{new_attr.inspect}] = val
+          end
+        end!
+      @attrs.push(new_attr)
+    end
+  end
+end

data/lib/d8a/d8a.rb

@@ -0,0 +1,205 @@
+# An abstract collection of named data.  In addition
+# to a name, each datum in the collection has 
+# a set of attributes associated with it.  This base
+# class is abstract; users should instantiate one of
+# the concrete subclasses of this class.
+#
+# Subclasses should provide the following methods:
+#
+# * an each method that yields the name of each datum
+#
+# * a read(d8m) {|io|} method.  The block will be
+#   invoked with an IO-like object that minimally supports
+#   a read method with the semantics of IO.read.  io is
+#   automatically closed when the block returns.  read()
+#   returns the value of the block.
+#
+# * a write(d8m) {|io|} method.  The block will be
+#   invoked with an IO-like object that minimally supports
+#   a write method with the semantics of IO.write.  io is
+#   automatically closed when the block returns.  write()
+#   returns the value of the block.
+#
+# * a delete(d8m) method
+#
+# * a flush method that callers can invok to indicate they
+#   are finished
+#
+# Attributes of datum can be defined by subclasses or modules
+# by appending the attribute's symbol to @attrs and supplying
+# the following methods:
+#
+# * <attr>(d8m, d8mattrs=nil) that returns the
+#   value of the requested attribute for the given d8m.
+#   If available, other attributes for the d8m will be
+#   supplied in the d8mattrs hash.
+#
+
+# * <attr>=(d8m, val) that sets the value of the attribute.  This is
+# optional; the attribute will be read-only if this method is not
+# provided.
+
+class D8a
+  include Enumerable
+
+  # D8a name
+  attr :d8aname
+
+
+  # Attrs for data
+  attr :attrs
+
+
+  # Identity attrs for data.  Users of this D8a can assume that a
+  # datum has not changed if all of these attributes remain constant.
+  attr :id_attrs
+
+
+  # Initialization
+  def initialize(d8aname)
+    @d8aname = d8aname
+    @attrs = [:name]
+    @id_attrs = []
+  end
+
+
+  # :name attribute
+  def name(d8m, *d8mattrs)
+    d8m
+  end
+
+
+  # Returns information about a named datum.
+  def [](d8m, attr = nil)
+    if attr
+      @attrs.include?(attr) ? __send__(attr, d8m) : nil
+
+    else
+      @attrs.inject({:name => d8m}) { |d8mattrs, attr|
+        val = __send__(attr, d8m, d8mattrs)
+        d8mattrs[attr] = val if val
+        d8mattrs
+      }
+    end
+  end
+
+
+  # Sets information about a named datum.
+  def []=(d8m, attr, val = nil)
+    if attr.is_a?(Hash)
+      attr.each { |k, v| self[d8m, k] = v }
+
+    elsif  @attrs.include?(attr)
+      begin
+        __send__((attr.to_s + "=").to_sym, d8m, val)
+      rescue NoMethodError
+        nil
+      end
+    end
+  end
+
+
+  # dummy implementation
+  def each
+    raise "each not implemented by this D8a"
+  end
+
+
+  # dummy implementation
+  def read(d8m)
+    raise "read(d8m) not implemented by this D8a"
+  end
+
+
+  # dummy implementation
+  def write(d8m)
+    raise "write(d8m) not implemented by this D8a"
+  end
+
+
+  # dummy implementation
+  def delete(d8m)
+    raise "delete(d8m) not implemented by this D8a"
+  end
+
+
+  # flush any cached data
+  def flush
+  end
+
+
+  # returns the different attributes for two d8m
+  def diff_d8m(d8m1, d8m2, d8a1, d8a2)
+    name = (d8m1||d8m2)[:name]
+
+    d8m1 ||= d8a1.attrs.inject({}) { |attrs,attr| attrs[attr] = nil; attrs }
+    d8m2 ||= d8a2.attrs.inject({}) { |attrs,attr| attrs[attr] = nil; attrs }
+
+    (d8m1.keys & d8m2.keys).find_all { |attr|
+      begin
+        d8m1[attr] != d8m2[attr]
+      rescue
+        true
+      end
+    }
+  end
+
+
+  # invokes block for each diff, returns entries in this not in o
+  def diff(o)
+    each do |d8m|
+      begin
+        myd8m = self[d8m]
+        od8m = o[d8m]
+        yield(myd8m, od8m) unless diff_d8m(myd8m, od8m, self, o).empty?
+      rescue Errno::ENOENT
+        yield(myd8m, nil)
+      end
+    end
+
+    o.each do |d8m|
+      begin
+        myd8m = self[d8m]
+      rescue Errno::ENOENT
+        yield(nil, o[d8m])
+      end
+    end
+  end
+
+
+  # Generates a report of differences as {name -> [:attr1,:attr2...]}
+  def diffreport(o)
+    result = {}
+
+    diff(o) do |a,b|
+      result[(a||b)[:name]] = diff_d8m(a, b, self, o)
+    end
+
+    result
+  end
+
+
+  # copy one datum to another
+  def copy(fromd8a, fromd8m, tod8a, tod8m = fromd8m)
+    fromd8a.read(fromd8m) do |r|
+      tod8a.write(tod8m) do |w|
+        while s = r.read(65536)
+          w.write(s)
+        end
+      end
+    end
+  end
+
+
+  # clones this D8a to another
+  def sync(to)
+    diff(to) do |myd8m,tod8m|
+      if myd8m
+        copy(self, myd8m[:name], to)
+        to[myd8m[:name]] = myd8m
+      else
+        to.delete(tod8m[:name])
+      end
+    end
+  end
+end

data/lib/d8a/digestd8a.rb

@@ -0,0 +1,83 @@
+require 'digest/md5'
+require 'd8a/cached8a'
+
+# Add digesting to an IO object
+module DigestIO
+  attr_accessor :digest
+
+  def DigestIO.extended(o)
+    class << o
+      alias_method :__digestio_read, :read
+      def read(*args)
+        s = __digestio_read(*args)
+        @digest << s if s
+        s
+      end
+
+      alias_method :__digestio_write, :write
+      def write(s)
+        i = __digestio_write(s)
+        @digest << s[0,i]
+        i
+      end
+    end
+
+    o.digest = Digest::MD5.new
+  end
+end
+
+
+# Add MD5 digest attributes to data.
+module DigestD8a
+  # d8m -> [mod time, digest] info for datum that we've seen
+  attr_accessor :digests
+
+
+  def DigestD8a.extended(d8a)
+    d8a.extend CacheD8a
+    d8a.synthetic_attr :md5
+
+
+    # redefine read/write to capture digests
+    class << d8a
+      alias_method :__digestd8a_read, :read
+      def read(d8m)
+        __digestd8a_read(d8m) do |f|
+          f.extend(DigestIO)
+          result = yield f
+          self[d8m, :md5] = f.digest.to_s
+          result
+        end
+      end
+
+
+      alias_method :__digestd8a_write, :write
+      def write(d8m)
+        digest = nil
+        __digestd8a_write(d8m) do |f|
+          f.extend(DigestIO)
+          digest = f.digest
+          yield f
+        end
+
+        # have to set this after the block since the id_attrs check
+        # in the caching logic will blow away anything we set before
+        # write returns
+
+        self[d8m, :md5] = digest.to_s
+      end
+    end
+  end
+
+
+  # forces recomputation of digest for a d8m
+  def compute_digest(d8m)
+    read(d8m) {|f|}
+  end
+
+
+  # force recomputation of all digests
+  def compute_digests
+    self.each { |d8m| compute_md5(d8m) }
+  end
+end

data/lib/d8a/filed8a.rb

@@ -0,0 +1,71 @@
+require 'd8a/d8a'
+require 'find'
+
+# D8a based on a directory tree.
+class FileD8a < D8a
+  # base directory
+  attr :basedir
+
+
+  def initialize(basedir, name = File.basename(basedir))
+    super(name)
+
+    File.directory?(basedir) || Dir.mkdir(basedir)
+    @basedir = basedir
+
+    @attrs.push(:size, :mtime, :mode)
+    @id_attrs.push(:size, :mtime)
+  end
+
+
+  # :size attribute
+  def size(d8m, d8mattrs = nil)
+    File.size(File.join(@basedir, d8m))
+  end
+
+
+  # :mtime attribute
+  def mtime(d8m, d8mattrs = nil)
+    File.mtime(File.join(@basedir, d8m))
+  end
+
+  def mtime=(d8m, mtime)
+    File.utime(mtime, mtime, File.join(@basedir, d8m))
+  end
+
+
+  # :mode attribute
+  def mode(d8m, d8mattrs = nil)
+    File.stat(File.join(@basedir, d8m)).mode & 0777
+  end
+
+  def mode=(d8m, mode)
+    File.chmod(mode, File.join(@basedir, d8m))
+  end
+
+
+
+  def each
+    Find.find(@basedir) do |f|
+      File.file?(f) && yield(f[(@basedir.length + 1)..-1])
+    end
+  end
+
+
+  # Reads a d8m
+  def read(d8m, &block)
+    File.open(File.join(@basedir, d8m), "r", &block)
+  end
+
+
+  # Writes a d8m
+  def write(d8m, &block)
+    File.open(File.join(@basedir, d8m), "w", &block)
+  end
+
+
+  # Deletes a d8m
+  def delete(d8m)
+    File.delete(File.join(@basedir, d8m))
+  end
+end

data/lib/d8a/ftpd8a.rb

@@ -0,0 +1,132 @@
+require 'd8a/d8a'
+require 'date'
+require 'net/ftp'
+
+# D8a based on an ftp site.
+class FtpD8a < D8a
+  # Proc(line, state_array) -> {} to process ls -R lines from server
+  attr :ls_parser
+
+
+  # set up a new Net::FTP connection
+  def FtpD8a.open(host, dir = nil, user = nil, passwd = nil, &block)
+    FtpD8a.new("ftp://#{user || ''}#{user ? '@' : ''}#{host}/#{dir || ''}") do |ftp|
+      ftp.close unless !ftp || ftp.closed?
+      ftp = Net::FTP.new(host, user, passwd)
+      ftp.chdir(dir) if dir
+      ftp
+    end
+  end
+
+    
+  # initializer
+  def initialize(name, ftp = nil, &block)
+    super(name)
+
+    @ftp_gen = block
+
+    @ftp = ftp
+    ensure_ftp
+
+    @attrs.push(:size, :ftpmtime, :mode)
+    @id_attrs.push(:size, :ftpmtime)
+ 
+
+    @ls_parser = Proc.new { |line,state|
+      case line
+      when /^$/
+        nil
+
+      when /^([-d])([-r][-w][-x][-r][-w][-x][-r][-w][-x])\s+\d+\s+\d+\s+\d+\s+(\d+)\s+(.{12})\s+(.*)$/
+        next nil if $1 == 'd'
+
+        name = state[0] + $5
+        size = $3.to_i
+        mode = eval("0b#{$2.tr('-rwx', '01')}")
+        ftpmtime =
+          case $4
+          when /^((Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+\d{4})$/
+            Date.strptime($2, '%b %e %Y')
+
+          when /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2})\s+(\d{1,2}:\d{2})$/
+            # TODO - this seems kind of clunky...
+            now = DateTime.now
+            Date.strptime("#{$1} #{$2} #{now.year}", '%b %e %Y') > now ?
+            Date.strptime("#{$1} #{$2} #{now.year-1} #{$3}", '%b %e %Y %R') :
+              Date.strptime("#{$1} #{$2} #{now.year} #{$3}", '%b %e %Y %R')
+          end
+
+        name.sub!(%r{^./}, '')
+
+        { :name => name, :size => size, :mode => mode, :ftpmtime => ftpmtime }
+
+      when /^(.*):$/
+        state[0] = $1 + "/"
+      end
+    }
+  end
+
+
+  private
+
+  # (re)sets up @ftp with an FTP connection to the host
+  def ensure_ftp
+    begin
+      @ftp.pwd
+    rescue
+      @ftp = @ftp_gen.call(@ftp) if @ftp_gen
+      @ftp.pwd
+    end
+  end
+
+
+  public
+
+  # size attr
+  def size(d8m, d8mattrs = nil)
+    @ftpcache[d8m] && @ftpcache[d8m][:size]
+  end
+
+
+  # ftpmtime attr
+  def ftpmtime(d8m, d8mattrs = nil)
+    @ftpcache[d8m] && @ftpcache[d8m][:ftpmtime]
+  end
+
+
+  # mode attr
+  def mode(d8m, d8mattrs = nil)
+    @ftpcache[d8m] && @ftpcache[d8m][:mode]
+  end
+
+
+  def each
+    ensure_ftp
+    dir = [""]
+    @ftpcache = {}
+    @ftp.list("-R") do |line|
+      if (x = @ls_parser.call(line, dir)).is_a?(Hash)
+        @ftpcache[x[:name]] = x
+        yield x[:name]
+      end
+    end
+  end
+
+
+  def read(d8m)
+  end
+
+
+  def write(d8m)
+  end
+
+
+  def delete(d8m)
+  end
+
+
+  def flush
+    #@ftp.close unless !@ftp || @ftp.closed?
+    #@ftp = nil
+  end
+end

data/tests/d8atest.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+require 'test/unit'
+require 'tmpdir'
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") unless
+  $:.include?(File.join(File.dirname(__FILE__), "..", "lib"))
+
+
+module TestD8a
+  include FileUtils
+
+  def setup_dirname(name)
+    File.join(Dir.tmpdir, "TestFileD8a", name)
+  end
+
+
+  def setup_filed8a(name, files)
+    dir = setup_dirname(name)
+    Dir.mkdir(dir)
+
+    files.each do |file|
+      fname = File.join(dir, file[0])
+      File.open(fname, "w") { |f| f.write("x" * file[1]) }
+      File.utime(file[2], file[2], fname)
+    end
+
+    @d8as[name] = { :dir => dir, :files => files }
+  end
+
+
+  def setup
+    @now = Time.at(Time.now.to_i)
+
+    @rootdir = File.join(Dir.tmpdir, "TestFileD8a")
+    File.directory?(@rootdir) || Dir.mkdir(@rootdir)
+
+    @d8as = {}
+
+    setup_filed8a("b", [["t0-s0", 0, Time.at(0)], ["tnow-s1000", 1000, @now]])
+    setup_filed8a("a", [])
+  end
+
+
+  def teardown
+    rm_rf(@rootdir) unless @skip_teardown
+    @d8as.clear
+  end
+
+
+  def assert_d8aequal(d8a1, d8a2)
+    errors = []
+    d8a1.diff(d8a2) do |d8m1,d8m2|
+      errors << [d8m1,d8m2]
+    end
+
+    assert_equal([], errors)
+  end
+end

data/tests/tc_cached8a.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'd8atest'
+require 'd8a/filed8a'
+require 'd8a/cached8a'
+
+
+class TestCacheD8a < Test::Unit::TestCase
+  include TestD8a
+
+  def test_cache
+    # add caching to a D8a
+    bd8a = FileD8a.new(@d8as["b"][:dir])
+    bd8a.extend CacheD8a
+
+    # create a phantom attr
+    bd8a.synthetic_attr :foo
+
+    assert(bd8a.respond_to?(:foo))
+    assert_equal(-2, bd8a.method(:foo).arity)
+    assert(bd8a.respond_to?(:foo=))
+    assert_equal(2, bd8a.method(:foo=).arity)
+
+    # set new attr on the files
+    bd8a["t0-s0", :foo] = 0
+    bd8a["tnow-s1000", :foo] = @now.to_i
+
+    # flush cache
+    bd8a.flush
+
+    # change timestamp on t0-s0 to invalidate cache entry
+    File.utime(1000, 1000, File.join(@d8as["b"][:dir], "t0-s0"))
+
+    # new D8a for same dir
+    xd8a = FileD8a.new(@d8as["b"][:dir])
+    xd8a.extend CacheD8a
+
+    # verify attr is still there
+    xd8a.synthetic_attr :foo
+
+    assert_nil(xd8a["t0-s0", :foo])
+    assert_equal(@now.to_i, xd8a["tnow-s1000", :foo])
+  end
+end

data/tests/tc_digestd8a.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'd8atest'
+require 'd8a/filed8a'
+require 'd8a/digestd8a'
+
+
+class TestDigestD8a < Test::Unit::TestCase
+  include TestD8a
+
+  def test_digest
+    # to compute our own digests
+    require "digest/md5"
+
+    # add digests to a D8a
+    bd8a = FileD8a.new(@d8as["b"][:dir])
+    bd8a.extend DigestD8a
+
+    assert(bd8a.respond_to?(:md5))
+    assert(bd8a.respond_to?(:md5=))
+
+    # should not be any digest to start with
+    assert_nil(bd8a["t0-s0", :md5])
+
+    # verify forced computation of digest
+    bd8a.compute_digest("t0-s0")
+    assert_equal(Digest::MD5.new.to_s, bd8a["t0-s0", :md5])
+
+    # verify digest is computed on read
+    assert_nil(bd8a["tnow-s1000", :md5])
+    bd8a.read("tnow-s1000") { |f|
+      while s = f.read(10000)
+      end
+    }
+    assert_equal((Digest::MD5.new << "x" * 1000).to_s,
+                 bd8a["tnow-s1000", :md5])
+
+    # verify digest is computed on write
+    bd8a.write("tnow-s1000") { |f| f.write("z" * 1000) }
+    assert_equal(d = (Digest::MD5.new << "z" * 1000).to_s,
+                 bd8a["tnow-s1000", :md5])
+
+    # verifiy digest is cached correctly
+    bd8a.flush
+    xd8a = FileD8a.new(@d8as["b"][:dir])
+    xd8a.extend DigestD8a
+
+    assert_equal(d, xd8a["tnow-s1000", :md5])
+  end
+end

data/tests/tc_filed8a.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(__FILE__)) unless
+  $:.include?(File.join(File.dirname(__FILE__)))
+
+require 'd8atest'
+require 'd8a/filed8a'
+require 'd8a/cached8a'
+
+
+class TestFileD8a < Test::Unit::TestCase
+  include TestD8a
+
+  def assert_contents(d8a, name = d8a.d8aname)
+    files = @d8as[name][:files].clone
+    errors = []
+
+    d8a.each do |d8m|
+      info = [d8a[d8m,:name], d8a[d8m,:size], d8a[d8m,:mtime]]
+      files.delete(info) || errors << "unrecognized d8m: #{info.inspect}"
+    end
+
+    files.each do |notfound|
+      errors << "missing d8m: #{notfound.inspect}"
+    end
+
+    assert_equal([], errors)
+  end
+
+
+  def assert_diffreportequal(dr1, dr2)
+    assert(dr1.size == dr2.size &&
+           dr1.all? { |d8m,attrs| (attrs - dr2[d8m]).empty? },
+           "#{dr1.inspect}\n#{dr2.inspect}")
+  end
+
+
+
+  def test_file
+    # validate known set of files
+    ad8a = FileD8a.new(@d8as["a"][:dir])
+    assert_contents(ad8a)
+
+    bd8a = FileD8a.new(@d8as["b"][:dir])
+    assert_contents(bd8a)
+
+
+    # create one from scratch
+    cdir = setup_dirname("c")
+    cd8a = FileD8a.new(cdir)
+
+    files = @d8as["b"][:files]
+    files.each do |f|
+      cd8a.write(f[0]) { |io| io.write('x' * f[1]) }
+      cd8a[f[0], :mtime] = f[2]
+    end
+    assert_equal(files.size + 2, Dir.entries(cdir).size)
+    files.each do |f|
+      assert_equal(f[1], cd8a[f[0], :size])
+      assert_equal(f[2], cd8a[f[0], :mtime])
+    end
+
+
+    # b and c should be identical
+    assert_d8aequal(cd8a, bd8a)
+
+
+    # create some diffs
+    File.open(File.join(@d8as["b"][:dir], "justb"), "w") do |f|
+      f.write("This file exists only in b.\n")
+    end
+
+    File.open(File.join(cdir, "justc"), "w") do |f|
+      f.write("This file exists only in c.\n")
+    end
+
+    File.open(File.join(@d8as["b"][:dir], "diffsize"), "w") do |f|
+      f.write("This file has different sizes in b & c.\n")
+    end
+    File.open(File.join(cdir, "diffsize"), "w") do |f|
+      f.write("This file has different sizes in b & c.  C is longer.\n")
+    end
+    t = File.mtime(File.join(@d8as["b"][:dir], "diffsize"))
+    File.utime(t, t, File.join(cdir, "diffsize"))
+
+    File.open(File.join(@d8as["b"][:dir], "diffmtime"), "w") do |f|
+      f.write("This file has different mtimes in b & c.\n")
+    end
+    File.open(File.join(cdir, "diffmtime"), "w") do |f|
+      f.write("This file has different mtimes in b & c.\n")
+    end
+    File.utime(0, 0, File.join(cdir, "diffmtime"))
+
+    assert_diffreportequal({"justb" => bd8a.attrs, "justc" => cd8a.attrs, "diffmtime" => [:mtime], "diffsize" => [:size]}, bd8a.diffreport(cd8a))
+  end
+end

data/tests/ts_d8a.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'tc_filed8a.rb'
+require 'tc_cached8a.rb'
+require 'tc_digestd8a.rb'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: d8a
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-02-19 00:00:00 -05:00
+summary: A uniform data library and associated tools
+require_paths: 
+- lib
+email: mike.j.burr@gmail.com
+homepage: http://d8a.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Mike Burr
+files: 
+- lib/d8a
+- lib/d8a/cached8a.rb
+- lib/d8a/ftpd8a.rb
+- lib/d8a/d8a.rb
+- lib/d8a/digestd8a.rb
+- lib/d8a/filed8a.rb
+- tests/tc_digestd8a.rb
+- tests/tc_filed8a.rb
+- tests/ts_d8a.rb
+- tests/tc_cached8a.rb
+- tests/d8atest.rb
+test_files: 
+- tests/ts_d8a.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: urirequire
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: