rpairtree 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4d0513966c46f689157aed52b75c1b10731fc2a
+  data.tar.gz: 18ecfb0525a2102152303d4c957e54fa62550a15
+SHA512:
+  metadata.gz: 20de254a99e42de2341801c3be0a39dd23130311dfcfb094c337ccee1c2713c68e17e805fde7d98b7e59d236c38bf5ff1820298c503f56a48c5553c1233244f5
+  data.tar.gz: 90de343158f62be17ae7b617d389fc865e86aa0142ac46316e1dfd7dee8b2d7d6826f47c08bf0fdcc43beb02f64e63696e44232dd7344e28679f890ea485168b

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,46 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+#*.swp
+#
+Gemfile.lock
+
+.idea/

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - jruby-18mode
+  - jruby-19mode
+script: bundle exec rake

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in test.gemspec
+gemspec
+
+
+gem 'rcov', :platform => :mri_18
+gem 'simplecov', :platforms => [:mri_19, :mri_20]
+gem 'simplecov-rcov', :platforms => [:mri_19, :mri_20]

data/LICENSE.txt

@@ -0,0 +1,12 @@
+###########################################################################
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,54 @@
+# (r)pairtree
+
+Ruby implementation of the [Pairtree](https://wiki.ucop.edu/display/Curation/PairTree) specification from the California Digital Library.
+
+## Description
+
+A fork of the seemingly-abandoned  [pairtree](https://github.com/microservices/pairtree).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rpairtree'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rpairtree
+
+## Usage
+
+```ruby
+  # Initiate a tree
+  pairtree = Pairtree.at('./data', :prefix => 'pfx:', :create => true)
+  
+  # Create a ppath
+  obj = pairtree.mk('pfx:abc123def')
+  
+  # Access an existing ppath
+  obj = pairtree['pfx:abc123def']
+  obj = pairtree.get('pfx:abc123def')
+  
+  # ppaths are Dir instances with some File and Dir class methods mixed in
+  obj.read('content.xml')
+  => "<content/>"
+  obj.open('my_file.txt','w') { |io| io.write("Write text to file") }
+  obj.entries
+  => ["content.xml","my_file.txt"]
+  obj['*.xml']
+  => ["content.xml"]
+  obj.each { |file| ... }
+  obj.unlink('my_file.txt')
+  
+  # Delete a ppath and all its contents
+  pairtree.purge!('pfx:abc123def')
+```
+
+

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |t|
+  if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.8/
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec', '--exclude', 'gems']
+  end
+end
+
+# Use yard to build docs
+begin
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+  project_root = File.expand_path(File.dirname(__FILE__))
+  doc_destination = File.join(project_root, 'doc')
+
+  YARD::Rake::YardocTask.new(:doc) do |yt|
+    yt.files   = Dir.glob(File.join(project_root, 'lib', '**', '*.rb')) + 
+                 [ File.join(project_root, 'README.md') ]
+    yt.options = ['--output-dir', doc_destination, '--readme', 'README.md']
+  end
+rescue LoadError
+  desc "Generate YARD Documentation"
+  task :doc do
+    abort "Please install the YARD gem to generate rdoc."
+  end
+end
+

data/lib/pairtree.rb

@@ -0,0 +1,78 @@
+require 'pairtree/identifier'
+require 'pairtree/path'
+require 'pairtree/obj'
+require 'pairtree/root'
+
+require 'fileutils'
+
+module Pairtree
+  class IdentifierError < Exception; end
+  class PathError < Exception; end
+  class VersionMismatch < Exception; end
+
+  SPEC_VERSION = 0.1
+  
+  ##
+  # Instantiate a pairtree at a given path location
+  # @param [String] path The path in which the pairtree resides
+  # @param [Hash] args Pairtree options
+  # @option args [String] :prefix (nil) the identifier prefix used throughout the pairtree
+  # @option args [String] :version (Pairtree::SPEC_VERSION) the version of the pairtree spec that this tree conforms to
+  # @option args [Boolean] :create (false) if true, create the pairtree and its directory structure if it doesn't already exist
+  def self.at path, args = {}
+    args = { :prefix => nil, :version => nil, :create => false }.merge(args)
+    args[:version] ||= SPEC_VERSION
+    args[:version] = args[:version].to_f
+    
+    root_path = File.join(path, 'pairtree_root')
+    prefix_file = File.join(path, 'pairtree_prefix')
+    version_file = File.join(path, pairtree_version_filename(args[:version]))
+    existing_version_file = Dir[File.join(path, "pairtree_version*")].sort.last
+    
+    if args.delete(:create)
+      if File.exists?(path) and not File.directory?(path)
+        raise PathError, "#{path} exists, but is not a valid pairtree root"
+      end
+      FileUtils.mkdir_p(root_path)
+
+      unless File.exists? prefix_file
+        File.open(prefix_file, 'w') { |f| f.write(args[:prefix].to_s) }
+      end
+      
+      if existing_version_file
+        if existing_version_file != version_file
+          stored_version = existing_version_file.scan(/([0-9]+)_([0-9]+)/).flatten.join('.').to_f
+          raise VersionMismatch, "Version #{args[:version]} specified, but #{stored_version} found."
+        end
+      else
+        args[:version] ||= SPEC_VERSION
+        version_file = File.join(path, pairtree_version_filename(args[:version]))
+        File.open(version_file, 'w') { |f| f.write %{This directory conforms to Pairtree Version #{args[:version]}. Updated spec: http://www.cdlib.org/inside/diglib/pairtree/pairtreespec.html} }
+        existing_version_file = version_file
+      end
+    else
+      unless File.directory? root_path
+        raise PathError, "#{path} does not point to an existing pairtree"
+      end
+    end
+
+    stored_prefix = File.read(prefix_file)
+    unless args[:prefix].nil? or args[:prefix].to_s == stored_prefix
+      raise IdentifierError, "Specified prefix #{args[:prefix].inspect} does not match stored prefix #{stored_prefix.inspect}"
+    end
+    args[:prefix] = stored_prefix
+
+    stored_version = existing_version_file.scan(/([0-9]+)_([0-9]+)/).flatten.join('.').to_f
+    args[:version] ||= stored_version
+    unless args[:version] == stored_version
+      raise VersionMismatch, "Version #{args[:version]} specified, but #{stored_version} found."
+    end
+        
+    Pairtree::Root.new(File.join(path, 'pairtree_root'), args)
+  end
+
+  private
+  def self.pairtree_version_filename(version)
+    "pairtree_version#{version.to_s.gsub(/\./,'_')}"
+  end
+end

data/lib/pairtree/identifier.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Pairtree
+  class Identifier
+    ENCODE_REGEX = Regexp.compile("[\"*+,<=>?\\\\^|]|[^\x21-\x7e]", nil)
+    DECODE_REGEX = Regexp.compile("\\^(..)", nil)
+
+    ##
+    # Encode special characters within an identifier
+    # @param [String] id The identifier
+    def self.encode id
+      id.gsub(ENCODE_REGEX) { |c| char2hex(c) }.tr('/:.', '=+,')
+    end
+
+    ##
+    # Decode special characters within an identifier
+    # @param [String] id The identifier
+    def self.decode id
+      input = id.tr('=+,', '/:.').bytes.to_a
+      intermediate = []
+      while input.first
+        if input.first == 94
+          h = []
+          input.shift
+          h << input.shift
+          h << input.shift
+          intermediate << h.pack('c*').hex
+        else
+          intermediate << input.shift
+        end
+      end
+      result = intermediate.pack('c*')
+      if result.respond_to? :force_encoding
+        result.force_encoding('UTF-8')
+      end
+      result
+    end
+
+    ##
+    # Convert a character to its pairtree hexidecimal representation
+    # @param [Char] c The character to convert
+    def self.char2hex c
+      c.unpack('H*')[0].scan(/../).map { |x| "^#{x}"}.join('')
+    end
+
+    ##
+    # Convert a pairtree hexidecimal string to its character representation
+    # @param [String] h The hexidecimal string to convert
+    def self.hex2char h
+       '' << h.delete('^').hex
+    end
+  end
+end

data/lib/pairtree/obj.rb

@@ -0,0 +1,52 @@
+module Pairtree  
+  class Obj < ::Dir
+    
+    FILE_METHODS = [:atime, :open, :read, :file?, :directory?, :exist?, :exists?, :file?, :ftype, :lstat, 
+      :mtime, :readable?, :size, :stat, :truncate, :writable?, :zero?]
+    FILE_METHODS.each do |file_method|
+      define_method file_method do |fname,*args,&block|
+        File.send(file_method, File.join(self.path, fname), *args, &block)
+      end
+    end
+
+    def delete *args
+      File.delete(*(prepend_filenames(args)))
+    end
+    alias_method :unlink, :delete
+
+    def link *args
+      File.link(*(prepend_filenames(args)))
+    end
+
+    def rename *args
+      File.rename(*(prepend_filenames(args)))
+    end
+    
+    def utime atime, mtime, *args
+      File.utime(atime, mtime, *(prepend_filenames(args)))
+    end
+    
+    def entries
+      super - ['.','..']
+    end
+    
+    def each &block
+      super { |entry| yield(entry) unless entry =~ /^\.{1,2}$/ }
+    end
+    
+    def glob(string, flags = 0)
+      result = Dir.glob(File.join(self.path, string), flags) - ['.','..']
+      result.collect { |f| f.sub(%r{^#{self.path}/},'') }
+    end
+    
+    def [](string)
+      glob(string, 0)
+    end
+    
+    private
+    def prepend_filenames(files)
+      files.collect { |fname| File.join(self.path, fname) }
+    end
+    
+  end
+end

data/lib/pairtree/path.rb

@@ -0,0 +1,50 @@
+module Pairtree
+  class Path
+    @@leaf_proc = lambda { |id| id }
+    
+    def self.set_leaf value = nil, &block
+      if value.nil?
+        @@leaf_proc = block
+      else
+        if value.is_a?(Proc)
+          @@leaf_proc = value
+        else
+          @@leaf_proc = lambda { |id| value }
+        end
+      end
+    end
+    
+    def self.leaf id
+      if @@leaf_proc
+        Pairtree::Identifier.encode(@@leaf_proc.call(id))
+      else
+        ''
+      end
+    end
+    
+    def self.id_to_path id
+      path = File.join(Pairtree::Identifier.encode(id).scan(/..?/),self.leaf(id))
+      path.sub(%r{#{File::SEPARATOR}+$},'')
+    end
+
+    def self.path_to_id ppath
+      parts = ppath.split(File::SEPARATOR)
+      parts.pop if @@leaf_proc and parts.last.length > Root::SHORTY_LENGTH
+      Pairtree::Identifier.decode(parts.join)
+    end
+    
+    def self.remove! path
+      FileUtils.remove_dir(path, true)
+      parts = path.split(File::SEPARATOR)
+      parts.pop
+      while parts.length > 0 and parts.last != 'pairtree_root'
+        begin
+          FileUtils.rmdir(parts.join(File::SEPARATOR))
+          parts.pop
+        rescue SystemCallError
+          break
+        end
+      end
+    end
+  end
+end

data/lib/pairtree/root.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+module Pairtree
+  class Root
+    SHORTY_LENGTH = 2
+
+    attr_reader :root, :prefix
+    
+    ##
+    # @param [String] root The pairtree_root directory within the pairtree home
+    # @param [Hash] args Pairtree options
+    # @option args [String] :prefix (nil) the identifier prefix used throughout the pairtree
+    # @option args [String] :version (Pairtree::SPEC_VERSION) the version of the pairtree spec that this tree conforms to
+    def initialize root, args = {}
+      @root = root
+      
+      @shorty_length = args.delete(:shorty_length) || SHORTY_LENGTH
+      @prefix = args.delete(:prefix) || ''
+
+      @options = args
+    end
+
+    ##
+    # Get a list of valid existing identifiers within the pairtree
+    # @return [Array]
+    def list          
+      objects = []
+      return [] unless File.directory? @root
+
+      Dir.chdir(@root) do
+        possibles = Dir['**/?'] + Dir['**/??']
+        possibles.each { |path|
+          contents = Dir.entries(path).reject { |x| x =~ /^\./ }
+          objects << path unless contents.all? { |f| f.length <= @shorty_length and File.directory?(File.join(path, f)) }
+        }
+      end
+      objects.map { |x| @prefix + Pairtree::Path.path_to_id(x) }
+    end
+
+    ##
+    # Get the path containing the pairtree_root
+    # @return [String]
+    def path
+      File.dirname(root)
+    end
+    
+    ##
+    # Get the full path for a given identifier (whether it exists or not)
+    # @param [String] id The full, prefixed identifier
+    # @return [String]
+    def path_for id
+      unless id.start_with? @prefix
+        raise IdentifierError, "Identifier must start with #{@prefix}"
+      end
+      path_id = id[@prefix.length..-1]
+      File.join(@root, Pairtree::Path.id_to_path(path_id))
+    end
+
+    ##
+    # Determine if a given identifier exists within the pairtree
+    # @param [String] id The full, prefixed identifier
+    # @return [Boolean]
+    def exists? id
+      File.directory?(path_for(id))
+    end
+    
+    ##
+    # Get an existing ppath
+    # @param [String] id The full, prefixed identifier
+    # @return [Pairtree::Obj] The object encapsulating the identifier's ppath
+    def get id
+      Pairtree::Obj.new path_for(id)
+    end
+    alias_method :[], :get
+    
+    ##
+    # Create a new ppath
+    # @param [String] id The full, prefixed identifier
+    # @return [Pairtree::Obj] The object encapsulating the newly created ppath
+    def mk id
+      FileUtils.mkdir_p path_for(id)
+      get(id)
+    end
+    
+    ##
+    # Delete a ppath
+    # @param [String] id The full, prefixed identifier
+    # @return [Boolean]
+    def purge! id
+      if exists?(id)
+        Pairtree::Path.remove!(path_for(id))
+      end
+      not exists?(id)
+    end
+
+    ##
+    # Get the version of the pairtree spec that this pairtree conforms to
+    # @return [String]
+    def pairtree_version
+      @options[:version]
+    end
+    
+  end
+end

data/lib/tasks/rdoc.rake

@@ -0,0 +1,32 @@
+desc "Generate RDoc"
+task :doc => ['doc:generate']
+
+namespace :doc do
+  project_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  doc_destination = File.join(project_root, 'rdoc')
+
+  begin
+    require 'yard'
+    require 'yard/rake/yardoc_task'
+
+    YARD::Rake::YardocTask.new(:generate) do |yt|
+      yt.files   =  Dir.glob(File.join(project_root, 'lib', '*.rb')) + 
+                    Dir.glob(File.join(project_root, 'lib', '**', '*.rb')) +
+                   [ File.join(project_root, 'README.rdoc') ] +
+                   [ File.join(project_root, 'LICENSE') ]
+                   
+      yt.options = ['--output-dir', doc_destination, '--readme', 'README.rdoc']
+    end
+  rescue LoadError
+    desc "Generate YARD Documentation"
+    task :generate do
+      abort "Please install the YARD gem to generate rdoc."
+    end
+  end
+
+  desc "Remove generated documenation"
+  task :clean do
+    rm_r doc_destination if File.exists?(doc_destination)
+  end
+
+end

data/pairtree.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name             = %q{rpairtree}
+  s.summary          = %q{Ruby Pairtree implementation, forked from pairtree which is abandoned.}
+  s.version          = "0.2.0"
+  s.homepage         = %q{http://github.com/mlibrary/pairtree}
+  s.licenses         = ["Apache2"]
+  s.authors          = ["Chris Beer, Bryan Hockey, Michael Slone"]
+  s.date             = %q{2015-05-05}
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.extra_rdoc_files = ["LICENSE.txt", "README.md"]
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec", ">= 2.0"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "rake"
+end
+

data/spec/pairtree/pairtree_encoding_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'pairtree'
+
+describe "Pairtree encoding" do
+
+  def roundtrip(id, expected_encoded=nil, expected_path=nil)
+    encoded = Pairtree::Identifier.encode(id)
+    unless expected_encoded.nil?
+      expect(encoded).to eql(expected_encoded)
+    end
+    unless expected_path.nil?
+      path = Pairtree::Path.id_to_path(id)
+      expect(path).to eql(expected_path)
+    end
+    str = Pairtree::Identifier.decode(encoded)
+    
+    if str.respond_to? :force_encoding
+      str.force_encoding("UTF-8")
+    end
+
+    expect(str).to eql(id)
+  end
+  
+  it "should handle a" do
+    roundtrip('a', 'a', 'a/a')
+  end
+
+  it "should handle ab" do
+    roundtrip('ab', 'ab', 'ab/ab')
+  end
+
+  it "should handle abc" do
+    roundtrip('abc', 'abc', 'ab/c/abc')
+  end
+
+  it "should handle abcd" do
+    roundtrip('abcd', 'abcd', 'ab/cd/abcd')
+  end
+
+  it "should handle space" do
+    roundtrip('hello world', 'hello^20world', 'he/ll/o^/20/wo/rl/d/hello^20world')
+  end
+
+  it "should handle slash" do
+    roundtrip("/","=",'=/=')
+  end
+
+  it "should handle urn" do
+    roundtrip('http://n2t.info/urn:nbn:se:kb:repos-1','http+==n2t,info=urn+nbn+se+kb+repos-1','ht/tp/+=/=n/2t/,i/nf/o=/ur/n+/nb/n+/se/+k/b+/re/po/s-/1/http+==n2t,info=urn+nbn+se+kb+repos-1')
+  end
+  
+  it "should handle wtf" do
+    roundtrip('what-the-*@?#!^!?', "what-the-^2a@^3f#!^5e!^3f", "wh/at/-t/he/-^/2a/@^/3f/#!/^5/e!/^3/f/what-the-^2a@^3f#!^5e!^3f")
+  end
+
+  it "should handle special characters" do
+    roundtrip('\\"*+,<=>?^|', "^5c^22^2a^2b^2c^3c^3d^3e^3f^5e^7c")
+  end
+  
+  it "should roundtrip hardcore Unicode" do
+    roundtrip(%{
+       1. Euro Symbol: €.
+       2. Greek: Μπορώ να φάω σπασμένα γυαλιά χωρίς να πάθω τίποτα.
+       3. Íslenska / Icelandic: Ég get etið gler án þess að meiða mig.
+       4. Polish: Mogę jeść szkło, i mi nie szkodzi.
+       5. Romanian: Pot să mănânc sticlă și ea nu mă rănește.
+       6. Ukrainian: Я можу їсти шкло, й воно мені не пошкодить.
+       7. Armenian: Կրնամ ապակի ուտել և ինծի անհանգիստ չըներ։
+       8. Georgian: მინას ვჭამ და არა მტკივა.
+       9. Hindi: मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा नहीं होती.
+      10. Hebrew(2): אני יכול לאכול זכוכית וזה לא מזיק לי.
+      11. Yiddish(2): איך קען עסן גלאָז און עס טוט מיר נישט װײ.
+      12. Arabic(2): أنا قادر على أكل الزجاج و هذا لا يؤلمني.
+      13. Japanese: 私はガラスを食べられます。それは私を傷つけません。
+      14. Thai: ฉันกินกระจกได้ แต่มันไม่ทำให้ฉันเจ็บ "
+    })
+  end
+  
+  it "should roundtrip French" do
+    roundtrip('Années de Pèlerinage', 'Ann^c3^a9es^20de^20P^c3^a8lerinage', 'An/n^/c3/^a/9e/s^/20/de/^2/0P/^c/3^/a8/le/ri/na/ge/Ann^c3^a9es^20de^20P^c3^a8lerinage')
+    roundtrip(%{
+      Années de Pèlerinage (Years of Pilgrimage) (S.160, S.161,
+      S.163) is a set of three suites by Franz Liszt for solo piano. Liszt's
+      complete musical style is evident in this masterwork, which ranges from
+      virtuosic fireworks to sincerely moving emotional statements. His musical
+      maturity can be seen evolving through his experience and travel. The
+      third volume is especially notable as an example of his later style: it
+      was composed well after the first two volumes and often displays less
+      showy virtuosity and more harmonic experimentation.
+    })
+ end
+  
+end

data/spec/pairtree/pairtree_obj_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'pairtree'
+
+describe "Pairtree::Obj" do
+
+  before(:all) do
+    @base_path = File.join(File.dirname(__FILE__), "../test_data/working")
+    Dir.chdir(File.join(File.dirname(__FILE__), "../test_data")) do
+      FileUtils.cp_r('fixtures/pairtree_root_spec', './working')
+    end
+    @root = Pairtree.at(@base_path)
+    @obj = @root.get('pfx:abc123def')
+  end
+  
+  after(:all) do
+    FileUtils.rm_rf(@base_path)
+  end
+  
+  it "should read a file" do
+    expect(@obj.read('content.xml')).to eql('<content/>')
+  end
+
+  it "should have entries" do
+    expect(@obj.entries).to eql(['content.xml'])
+  end
+  
+  it "should glob" do
+    expect(@obj['*.xml']).to eql(['content.xml'])
+    expect(@obj['*.txt']).to eql([])
+  end
+  
+  it "should be enumerable" do
+    block_body = double('block_body')
+    expect(block_body).to receive(:yielded).with('content.xml')
+    @obj.each { |file| block_body.yielded(file) }
+  end
+  
+  describe "Call a bunch of File methods" do
+    before(:each) do
+      @target = File.join(@base_path, 'pairtree_root/ab/c1/23/de/f/abc123def/content.xml')
+    end
+    
+    it "should open a file" do
+      expect(File).to receive(:open).with(@target,'r')
+      @obj.open('content.xml','r')
+    end
+
+    it "should call delete" do
+      expect(File).to receive(:delete).with(@target)
+      @obj.delete('content.xml')
+    end
+
+    it "should call link" do
+      expect(File).to receive(:link).with(@target,@target + '.2')
+      @obj.link('content.xml','content.xml.2')
+    end
+
+    it "should call rename" do
+      expect(File).to receive(:rename).with(@target,@target + '.new')
+      @obj.rename('content.xml','content.xml.new')
+    end
+
+    it "should call utime" do
+      expect(File).to receive(:utime).with(0,1,@target)
+      @obj.utime(0,1,'content.xml')
+    end
+  end
+  
+end

data/spec/pairtree/pairtree_path_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'pairtree'
+
+describe "Pairtree::Path" do
+  
+  after(:each) do
+    Pairtree::Path.set_leaf { |id| id }
+  end
+  
+  it "should generate an encoded id as the leaf path by default" do
+    expect(Pairtree::Path.leaf('abc/def')).to eql("abc=def")
+  end
+
+  it "should accept a nil override" do
+    Pairtree::Path.set_leaf nil
+    expect(Pairtree::Path.leaf('abc/def')).to eql("")
+  end
+  
+  it "should accept a scalar override" do
+    Pairtree::Path.set_leaf 'obj'
+    expect(Pairtree::Path.leaf('abc/def')).to eql("obj")
+  end
+  
+  it "should accept a Proc override" do
+    lp = Proc.new { |id| id.reverse }
+    Pairtree::Path.set_leaf(lp)
+    expect(Pairtree::Path.leaf('abc/def')).to eql("fed=cba")
+  end
+  
+  it "should accept a block override" do
+    Pairtree::Path.set_leaf { |id| id.reverse }
+    expect(Pairtree::Path.leaf('abc/def')).to eql("fed=cba")
+  end
+  
+end

data/spec/pairtree/pairtree_root_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'pairtree'
+
+describe "Pairtree::Root" do
+  
+  before(:all) do
+    @base_path = File.join(File.dirname(__FILE__), "../test_data/working")
+    Dir.chdir(File.join(File.dirname(__FILE__), "../test_data")) do
+      FileUtils.cp_r('fixtures/pairtree_root_spec', './working')
+    end
+    @root = Pairtree.at(@base_path)
+  end
+  
+  after(:all) do
+    FileUtils.rm_rf(@base_path)
+  end
+  
+  it "should have the correct prefix" do
+    expect(@root.prefix).to eql('pfx:')
+  end
+  
+  it "should be in the correct location" do
+    expect(File.expand_path(@root.path)).to eql(File.expand_path(@base_path))
+    expect(File.expand_path(@root.root)).to eql(File.expand_path(File.join(@base_path, "pairtree_root")))
+  end
+  
+  it "should list identifiers" do
+    expect(@root.list).to eql(['pfx:abc123def'])
+  end
+  
+  it "should verify whether an identifier exists" do
+    expect(@root.exists?('pfx:abc123def')).to be true
+    expect(@root.exists?('pfx:abc123jkl')).to be false
+  end
+  
+  it "should raise an exception if an invalid prefix is used" do
+    expect { @root.exists?('xfp:abc123def') }.to raise_error(Pairtree::IdentifierError)
+  end
+  
+  it "should get a ppath for a valid ID" do
+    obj = @root.get 'pfx:abc123def'
+    expect(obj.class).to eql(Pairtree::Obj)
+    expect(File.expand_path(obj.path)).to eql(File.expand_path(File.join(@base_path, "pairtree_root/ab/c1/23/de/f/abc123def/")))
+  end
+  
+  it "should raise an exception when attempting to get a ppath for an invalid ID" do
+    expect { @root.get 'pfx:abc123jkl' }.to raise_error(Errno::ENOENT)
+  end
+  
+  it "should create a new ppath" do
+    obj = @root.mk 'pfx:abc123jkl'
+    expect(obj.class).to eql(Pairtree::Obj)
+    expect(File.expand_path(obj.path)).to eql(File.expand_path(File.join(@base_path, "pairtree_root/ab/c1/23/jk/l/abc123jkl/")))
+    expect(@root.exists?('pfx:abc123jkl')).to be true
+  end
+  
+  it "should delete a ppath" do
+    expect(@root.exists?('pfx:abc123jkl')).to be true
+    @root.purge!('pfx:abc123jkl')
+    expect(@root.exists?('pfx:abc123jkl')).to be false
+  end
+  
+end

data/spec/pairtree/pairtree_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'pairtree'
+
+describe "Pairtree" do
+  
+  before(:all) do
+    @base_path = File.join(File.dirname(__FILE__), "../test_data/working")
+  end
+  
+  it "should raise an error if a non-existent is specified without :create" do
+    expect { Pairtree.at(@base_path) }.to raise_error(Pairtree::PathError)
+  end
+
+  describe "new pairtree" do
+    after(:all) do
+      FileUtils.rm_rf(@base_path)
+    end
+
+    it "should create a new pairtree" do
+      prefix = 'my_prefix:'
+      pt = Pairtree.at(@base_path, :prefix => prefix, :create => true)
+      expect(pt.prefix).to eql(prefix)
+      expect(File.read(File.join(@base_path,'pairtree_prefix'))).to eql(prefix)
+      expect(pt.root).to eql(File.join(@base_path, 'pairtree_root'))
+      expect(pt.pairtree_version).to eql(Pairtree::SPEC_VERSION)
+    end
+    
+  end
+  
+  describe "existing pairtree" do
+    before(:all) do
+      Dir.chdir(File.join(File.dirname(__FILE__), "../test_data")) do
+        FileUtils.cp_r('fixtures/pairtree_root_spec', './working')
+      end
+    end
+    
+    after(:all) do
+      FileUtils.rm_rf(@base_path)
+    end
+
+    it "should raise an error if a regular file is specified as a root" do
+      expect { Pairtree.at(File.join(@base_path, "pairtree_prefix"), :create => true) }.to raise_error(Pairtree::PathError)
+    end
+    
+    it "should read the prefix if none is specified" do
+      expect(Pairtree.at(@base_path).prefix).to eql(File.read(File.join(@base_path, 'pairtree_prefix')))
+    end
+
+    it "should not complain if the given prefix matches the saved prefix" do
+      expect(Pairtree.at(@base_path, :prefix => 'pfx:').prefix).to eql(File.read(File.join(@base_path, 'pairtree_prefix')))
+    end
+    
+    it "should raise an error if the given prefix does not match the saved prefix" do
+      expect { Pairtree.at(@base_path, :prefix => 'wrong-prefix:') }.to raise_error(Pairtree::IdentifierError)
+    end
+    
+    it "should not complain if the given version matches the saved version" do
+      expect(Pairtree.at(@base_path, :version => Pairtree::SPEC_VERSION).pairtree_version).to eql(Pairtree::SPEC_VERSION)
+      expect(Pairtree.at(@base_path, :version => Pairtree::SPEC_VERSION, :create => true).pairtree_version).to eql(Pairtree::SPEC_VERSION)
+    end
+
+    it "should raise an error if the given version does not match the saved version" do
+      expect { Pairtree.at(@base_path, :version => 0.2) }.to raise_error(Pairtree::VersionMismatch)
+      expect { Pairtree.at(@base_path, :version => 0.2, :create => true) }.to raise_error(Pairtree::VersionMismatch)
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'bundler/setup'
+require 'rspec'
+
+if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'pairtree'
+
+RSpec.configure do |config|
+  
+end

data/spec/test_data/fixtures/pairtree_root_spec/pairtree_prefix

@@ -0,0 +1 @@
+pfx:

data/spec/test_data/fixtures/pairtree_root_spec/pairtree_root/ab/c1/23/de/f/abc123def/content.xml

@@ -0,0 +1 @@
+<content/>

data/spec/test_data/fixtures/pairtree_root_spec/pairtree_version0_1

@@ -0,0 +1 @@
+This directory conforms to Pairtree Version 0.1. Updated spec: http://www.cdlib.org/inside/diglib/pairtree/pairtreespec.html

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: rpairtree
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Chris Beer, Bryan Hockey, Michael Slone
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pairtree.rb
+- lib/pairtree/identifier.rb
+- lib/pairtree/obj.rb
+- lib/pairtree/path.rb
+- lib/pairtree/root.rb
+- lib/tasks/rdoc.rake
+- pairtree.gemspec
+- spec/pairtree/pairtree_encoding_spec.rb
+- spec/pairtree/pairtree_obj_spec.rb
+- spec/pairtree/pairtree_path_spec.rb
+- spec/pairtree/pairtree_root_spec.rb
+- spec/pairtree/pairtree_spec.rb
+- spec/spec_helper.rb
+- spec/test_data/fixtures/pairtree_root_spec/pairtree_prefix
+- spec/test_data/fixtures/pairtree_root_spec/pairtree_root/ab/c1/23/de/f/abc123def/content.xml
+- spec/test_data/fixtures/pairtree_root_spec/pairtree_version0_1
+homepage: http://github.com/mlibrary/pairtree
+licenses:
+- Apache2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ruby Pairtree implementation, forked from pairtree which is abandoned.
+test_files: []
+has_rdoc: