moab-versioning 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 314bede5bec369d49b3173b4cb6ca49b67dad86c
-  data.tar.gz: 2efefdc7fa3a28b69e45778fd1a373be555d4a4b
+  metadata.gz: 8a0b643706a4149747c76abbbbdb8458a73c62ed
+  data.tar.gz: 485960168209b4768a76deb35fbd56360a8b32e3
 SHA512:
-  metadata.gz: 26daf2d5fa9f5a859676313a180ba5c73acb2e441b73cdfb6cdafc847e043521764e469512f364dead19fb0ea5d3d095f5e666d97f3362112ca08cb8b5d93685
-  data.tar.gz: 9638f3dcec4715d837abde7bc3c7f28713553692482b1ea3b93c3d654000bd6fb0cc6100af01266bc0aec94863c3f006ae9177117b4d3667af38accc67dd4925
+  metadata.gz: 26f4fee9182c007e5c68fdef45a53fbb75330dfcdc9ed39e02e719a095a1a4d684adbb2ab7ff049fa15631cf1e72711f78b3b6ee2633a99f31c264f2b77ddb05
+  data.tar.gz: 31c2bc1b8120546686d6952b06ab2b20b046d4f010a829bb546bc3c4669832ac15ef627b388dd4414e6c59e2628b1737f7a1c2dc1d07c37c3d26db9f365babea

data/lib/moab/bagger.rb

@@ -90,9 +90,11 @@ module Moab
     end
 
     # @api external
-    # @param package_mode [Symbol] The operational mode controlling what gets bagged and the full path of source files (Bagger#fill_payload)
+    # @param package_mode [Symbol] The operational mode controlling what gets bagged and the full path of
+    #   source files (Bagger#fill_payload)
     # @param source_base_pathname [Pathname] The home location of the source files
-    # @return [Bagger] Perform all the operations required to fill the bag payload, write the manifests and tagfiles, and checksum the tagfiles
+    # @return [Bagger] Perform all the operations required to fill the bag payload, write the manifests and
+    #   tagfiles, and checksum the tagfiles
     # @example {include:file:spec/features/storage/deposit_spec.rb}
     def fill_bag(package_mode, source_base_pathname)
       create_bag_inventory(package_mode)
@@ -102,7 +104,8 @@ module Moab
     end
 
     # @api external
-    # @param package_mode [Symbol] The operational mode controlling what gets bagged and the full path of source files (Bagger#fill_payload)
+    # @param package_mode [Symbol] The operational mode controlling what gets bagged and the full path of
+    #   source files (Bagger#fill_payload)
     # @return [FileInventory] Create, write, and return the inventory of the files that will become the payload
     def create_bag_inventory(package_mode)
       @package_mode = package_mode

data/lib/moab/file_group.rb

@@ -155,11 +155,10 @@ module Moab
 
     # @return [Pathname] The full path used as the basis of the relative paths reported
     #   in {FileInstance} objects that are children of the {FileManifestation} objects contained in this file group
-    attr_accessor :base_directory
-
     def base_directory=(basepath)
       @base_directory = Pathname.new(basepath).expand_path
     end
+    attr_reader :base_directory
 
     # @api internal
     # @param pathname [Pathname] The file path to be tested
@@ -241,4 +240,3 @@ module Moab
   end
 
 end
-

data/lib/moab/file_group_difference.rb

@@ -63,7 +63,8 @@ module Moab
     attribute :group_id, String, :tag => 'groupId', :key => true
 
     # @attribute
-    # @return [Integer] the total number of differences found between the two inventories that were compared  (dynamically calculated)
+    # @return [Integer] the total number of differences found between the two inventories that were
+    #   compared  (dynamically calculated)
     attribute :difference_count, Integer, :tag => 'differenceCount', :on_save => Proc.new { |i| i.to_s }
 
     def difference_count
@@ -263,14 +264,13 @@ module Moab
           fid.basis_path = basis_only_paths[n]
           fid.other_path = other_only_paths[n]
           fid.signatures << signature
-          case true
-            when fid.basis_path.nil?
-              fid.change = 'copyadded'
-              fid.basis_path = basis_paths[0]
-            when fid.other_path.nil?
-              fid.change = 'copydeleted'
-            else
-              fid.change = 'renamed'
+          if fid.basis_path.nil?
+            fid.change = 'copyadded'
+            fid.basis_path = basis_paths[0]
+          elsif fid.other_path.nil?
+            fid.change = 'copydeleted'
+          else
+            fid.change = 'renamed'
           end
           @subset_hash[fid.change.to_sym].files << fid
         end

data/lib/moab/file_instance_difference.rb

@@ -5,7 +5,8 @@ module Moab
   # A container for recording difference information at the file level
   # * If there was no change, the change type is set to <i>identical</i>
   # * If the signature is unchanged, but the path has moved, the change type is set to <i>renamed</i>
-  # * If path is unchanged, but the signature has changed, the change type is set to <i>modified</i> and both signatures are reported
+  # * If path is unchanged, but the signature has changed, the change type is set to <i>modified</i> and
+  #  both signatures are reported
   # * If the signature and path are only in the basis inventory, the change type is set to <i>deleted</i>
   # * If the signature and path are only in the other inventory, the change type is set to <i>added</i>
   # This is a child element of {FileGroupDifferenceSubset}, which is in turn a descendent of {FileInventoryDifference},
@@ -51,4 +52,4 @@ module Moab
 
   end
 
-end
+end

data/lib/moab/file_inventory.rb

@@ -134,9 +134,11 @@ module Moab
     # @return [FileSignature] The signature of the specified file
     def file_signature(group_id, file_id)
       file_group = group(group_id)
-      raise FileNotFoundException, "group #{group_id} not found for #{@digital_object_id} - #{@version_id}" if file_group.nil?
+      errmsg = "group #{group_id} not found for #{@digital_object_id} - #{@version_id}"
+      raise FileNotFoundException, errmsg if file_group.nil?
       file_signature = file_group.path_hash[file_id]
-      raise FileNotFoundException, "#{group_id} file #{file_id} not found for #{@digital_object_id} - #{@version_id}" if file_signature.nil?
+      errmsg = "#{group_id} file #{file_id} not found for #{@digital_object_id} - #{@version_id}"
+      raise FileNotFoundException, errmsg if file_signature.nil?
       file_signature
     end
 
@@ -182,19 +184,20 @@ module Moab
     #   if nil, then the directory is assumed to contain both content and metadata subdirectories
     # @return [FileInventory] Traverse a directory and return an inventory of the files it contains
     # @example {include:file:spec/features/inventory/harvest_inventory_spec.rb}
-    def inventory_from_directory(data_dir,group_id=nil)
+    def inventory_from_directory(data_dir, group_id=nil)
       if group_id
-        @groups << FileGroup.new(:group_id=>group_id).group_from_directory(data_dir)
+        @groups << FileGroup.new(group_id: group_id).group_from_directory(data_dir)
       else
-        ['content','metadata'].each do |group_id|
-          @groups << FileGroup.new(:group_id=>group_id).group_from_directory(Pathname(data_dir).join(group_id))
+        ['content', 'metadata'].each do |gid|
+          @groups << FileGroup.new(group_id: gid).group_from_directory(Pathname(data_dir).join(gid))
         end
       end
       self
     end
 
     # @param  bag_dir [Pathname,String] The location of the BagIt bag to be inventoried
-    # @return [FileInventory] Traverse a BagIt bag's payload and return an inventory of the files it contains (using fixity from bag manifest files)
+    # @return [FileInventory] Traverse a BagIt bag's payload and return an inventory of the files it contains
+    #  (using fixity from bag manifest files)
     def inventory_from_bagit_bag(bag_dir)
       bag_pathname = Pathname(bag_dir)
       signatures_from_bag = signatures_from_bagit_manifests(bag_pathname)
@@ -261,7 +264,7 @@ module Moab
         when "directory"
           'directoryInventory.xml'
         else
-          raise "unknown inventory type: #{type.to_s}"
+          raise ArgumentError, "unknown inventory type: #{type.to_s}"
       end
     end
 

data/lib/moab/file_signature.rb

@@ -79,7 +79,7 @@ module Moab
         when :sha256
           @sha256 = value
         else
-          raise "Unknown checksum type '#{type.to_s}'"
+          raise ArgumentError, "Unknown checksum type '#{type.to_s}'"
       end
     end
 

data/lib/moab/storage_object.rb

@@ -115,7 +115,8 @@ module Moab
     # @return [Pathname] The absolute storage path of the file, including the object's home directory
     def storage_filepath(catalog_filepath)
       storage_filepath = @object_pathname.join(catalog_filepath)
-      raise FileNotFoundException, "#{catalog_filepath} missing from storage location #{storage_filepath}" unless storage_filepath.exist?
+      errmsg = "#{catalog_filepath} missing from storage location #{storage_filepath}"
+      raise FileNotFoundException, errmsg unless storage_filepath.exist?
       storage_filepath
     end
 
@@ -132,7 +133,7 @@ module Moab
       return list unless @object_pathname.exist?
       @object_pathname.children.each do |dirname|
         vnum = dirname.basename.to_s
-        if vnum.match /^v(\d+)$/
+        if vnum =~ /^v(\d+)$/
           list << vnum[1..-1].to_i
         end
       end
@@ -153,11 +154,7 @@ module Moab
     # @api external
     # @return [Integer] The identifier of the latest version of this object, or 0 if no versions exist
     def current_version_id
-      return @current_version_id unless @current_version_id.nil?
-      #@current_version_id = self.version_id_list.last || 0
-      list = self.version_id_list
-      version_id = list.empty? ? 0 : list.last
-      @current_version_id = version_id
+      @current_version_id ||= self.version_id_list.last || 0
     end
 
     # @return [StorageObjectVersion] The most recent version in the storage object
@@ -218,7 +215,7 @@ module Moab
     # @return [Boolean] Restore all recovered versions to online storage and verify results
     def restore_object(recovery_path)
       timestamp = Time.now
-      recovery_object = StorageObject.new(@digital_object_id, recovery_path, mkpath=false)
+      recovery_object = StorageObject.new(@digital_object_id, recovery_path, false)
       recovery_object.versions.each do |recovery_version|
         version_id = recovery_version.version_id
         storage_version = self.storage_object_version(version_id)
@@ -230,6 +227,14 @@ module Moab
       self
     end
 
+    # @return [Integer] the size occupied on disk by the storage object, in bytes.  this is the entire moab (all versions).
+    def size
+      size = 0
+      Find.find(object_pathname) do |path|
+        size += FileTest.size(path) unless FileTest.directory?(path)
+      end
+      size
+    end
   end
 
 end

data/lib/moab/storage_object_version.rb

@@ -204,8 +204,9 @@ module Moab
           :type=>'manifests',
           :digital_object_id=>@storage_object.digital_object_id,
           :version_id=>@version_id)
-      manifest_inventory.groups << FileGroup.new(:group_id=>'manifests').group_from_directory(@version_pathname.join('manifests'), recursive=false)
-      manifest_inventory.write_xml_file(@version_pathname.join('manifests'))
+      pathname = @version_pathname.join('manifests')
+      manifest_inventory.groups << FileGroup.new(:group_id=>'manifests').group_from_directory(pathname, false)
+      manifest_inventory.write_xml_file(pathname)
     end
 
     # @return [VerificationResult] return result of testing correctness of version manifests
@@ -330,7 +331,5 @@ module Moab
         @version_pathname.rename(demote_pathame)
       end
     end
-
   end
-
 end

data/lib/moab/storage_repository.rb

@@ -15,8 +15,9 @@ module Moab
   #   All rights reserved.  See {file:LICENSE.rdoc} for details.
   class StorageRepository
 
-    #Note that Moab::Config is not initialized from environment config file until after this object is initialized by StorageServices
-    #   (see sequence of requires in spec_helper.rb and in applications that use)
+    # Note that Moab::Config is not initialized from environment config file until after
+    #  this object is initialized by StorageServices
+    #  (see sequence of requires in spec_helper.rb and in applications that use)
 
     # @return [Array<Pathname>] The list of filesystem root paths in which objects are stored
     def storage_roots
@@ -45,7 +46,7 @@ module Moab
       # split a object ID into 2-character segments, followed by a copy of the object ID
       # for a more sophisticated pairtree implementation see https://github.com/microservices/pairtree
       path_segments = object_id.scan(/..?/) << object_id
-      path_segments.join(File::SEPARATOR).gsub(/:/,'_')
+      path_segments.join(File::SEPARATOR).tr(':', '_')
     end
 
     # @return [String] The trunk segment of the object deposit path
@@ -109,11 +110,7 @@ module Moab
       storage_pathname = find_storage_object(object_id, include_deposit).object_pathname
       size = 0
       Find.find(storage_pathname) do |path|
-        if FileTest.directory?(path)
-          Find.prune if File.basename(path)[0] == '.'
-        else
-          size += FileTest.size(path)
-        end
+        size += FileTest.size(path) unless FileTest.directory?(path)
       end
       size
     end

data/lib/stanford/content_inventory.rb

@@ -20,7 +20,8 @@ module Stanford
     # @return [FileInventory] The versionInventory equivalent of the contentMetadata
     #   if the supplied content_metadata is blank or empty, then a skeletal FileInventory will be returned
     def inventory_from_cm(content_metadata, object_id, subset, version_id=nil)
-      # The contentMetadata datastream is not required for ingest, since some object types, such as collection or APO do not require one.
+      # The contentMetadata datastream is not required for ingest, since some object types, such as collection
+      #   or APO do not require one.
       # Many of these objects have contentMetadata with no child elements, such as this:
       #    <contentMetadata objectId="bd608mj3166" type="file"/>
       # but there are also objects that have no datasteam of this name at all

data/lib/stanford/dor_metadata.rb

@@ -33,7 +33,7 @@ module Stanford
     # @return [FileInventory]  Inventory of the files under the specified directory
     def inventory_from_directory(directory, version_id=nil)
       version_id ||= @version_id
-      version_inventory = Moab::FileInventory.new(:type=>'version',:digital_object_id=>@digital_object_id, :version_id=>version_id)
+      version_inventory = Moab::FileInventory.new(type: 'version', digital_object_id: @digital_object_id, version_id: version_id)
       content_metadata = IO.read(File.join(directory,'contentMetadata.xml'))
       content_group = Stanford::ContentInventory.new.group_from_cm(content_metadata, 'preserve' )
       version_inventory.groups << content_group
@@ -41,9 +41,6 @@ module Stanford
       version_inventory.groups << metadata_group
       version_inventory
     end
-
-
-
   end
 
-end
+end

data/lib/stanford/storage_repository.rb

@@ -1,4 +1,5 @@
 require 'moab/stanford'
+require 'druid-tools'
 
 module Stanford
 
@@ -15,10 +16,10 @@ module Stanford
     # @return [String] The branch segment of the object storage path
     def storage_branch(object_id)
       case Moab::Config.path_method.to_s
-        when 'druid_tree'
-          druid_tree(object_id)
-        when 'druid'
-          object_id.split(/:/)[-1]
+      when 'druid_tree'
+        druid_tree(object_id)
+      when 'druid'
+        object_id.split(/:/)[-1]
       end
     end
 
@@ -31,22 +32,15 @@ module Stanford
     # @param object_id [String] The identifier of the digital object whose path is requested
     # @return [String] the druid tree directory path based on the given object identifier.
     def druid_tree(object_id)
+      # Note: this seems an odd place to do druid validation, but leaving it here for now
       syntax_msg = "Identifier has invalid suri syntax: #{object_id}"
-      raise syntax_msg + "nil or empty" if object_id.to_s.empty?
+      raise syntax_msg + " nil or empty" if object_id.to_s.empty?
       identifier = object_id.split(':')[-1]
-      raise syntax_msg if  identifier.to_s.empty?
-      # The object identifier must be in the SURI format, otherwise an exception is raised:
-      # e.g. druid:aannnaannnn or aannnaannnn
-      # where 'a' is an alphabetic character
-      # where 'n' is a numeric character
-      if identifier =~ /^([a-z]{2})(\d{3})([a-z]{2})(\d{4})$/
-        return File.join( $1, $2, $3, $4, identifier)
-      else
-        raise syntax_msg
-      end
+      raise syntax_msg if identifier.to_s.empty?
+      raise syntax_msg unless DruidTools::Druid.valid?(identifier, true)
+      DruidTools::Druid.new(identifier, true).tree.join(File::SEPARATOR)
     end
 
-
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moab-versioning
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Darren Weber
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-07 00:00:00.000000000 Z
+date: 2017-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: confstruct
@@ -83,6 +83,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: druid-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -201,28 +215,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.1
+        version: 0.50.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.1
+        version: 0.50.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.0
+        version: 1.18.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.0
+        version: 1.18.0
 description: Contains classes to process digital object version content and metadata
 email:
 - darren.weber@stanford.edu
@@ -264,9 +278,6 @@ files:
 - lib/stanford/storage_repository.rb
 - lib/stanford/storage_services.rb
 - lib/tasks/yard.rake
-- lib/tools/api_doc_generator.rb
-- lib/tools/spec_generator.rb
-- lib/tools/spec_generator_old.rb
 homepage: https://github.com/sul-dlss/moab-versioning
 licenses:
 - Apache-2.0
@@ -287,7 +298,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of digital object versioning toolkit used by the SULAIR

data/lib/tools/api_doc_generator.rb

@@ -1,395 +0,0 @@
-#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
-require 'rubygems'
-require 'pathname'
-require 'yard'
-include YARD
-require 'moab/stanford'
-include Serializer
-include Moab
-include Stanford
-
-class String
-  def snake_case
-    self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-        gsub(/([a-z\d])([A-Z])/, '\1_\2').
-        tr("-", "_").
-        downcase
-  end
-end
-
-class Symbol
-  def snake_case
-    self.to_s.snake_case
-  end
-end
-
-class ApiClass
-  attr_accessor :class_name
-  attr_accessor :yard_class
-  attr_accessor :mhash
-  attr_accessor :ruby_class
-  attr_accessor :xml_tag
-  attr_accessor :description
-  attr_accessor :model
-
-  def self.class_hash=(class_hash)
-    @@class_hash = class_hash
-  end
-
-  def self.rootpath=(rootpath)
-    @@rootpath = rootpath
-  end
-
-  def initialize(class_name)
-    @class_name = class_name
-    @yard_class = @@class_hash[class_name]
-    if @yard_class.nil?
-      raise "class_hash[#{class_name}] is Nil"
-    end
-    @mhash = categorize_members(@yard_class)
-    if @yard_class.path.include?('::')
-      ruby_module = Object::const_get(yard_class.path.split(/::/)[0])
-      @ruby_class = ruby_module.const_get(yard_class.name)
-    else
-      @ruby_class = Object::const_get(yard_class.path)
-    end
-
-    if @ruby_class.respond_to?(:tag_name)
-      @xml_tag = "<#{ruby_class.tag_name}>"
-    else
-      @xml_tag = '-'
-    end
-    docstring_all = confluence_translate(yard_class.docstring.all.split(/@/)[0])
-    docstring_parts = docstring_all.split(/h4. Data Model\n/)
-    @description = docstring_parts[0]
-    @model = docstring_parts.size > 1 ? docstring_parts[1] : nil
-  end
-
-  def categorize_members(yard_class)
-    mhash = {
-        :class_attributes => Hash.new,
-        :instance_attributes => Hash.new,
-        :class_methods => Array.new,
-        :instance_methods => Array.new
-    }
-    yard_class.children.each do |member|
-      attr_symbol = member.name.to_s.gsub(/=$/, '').to_sym
-      if member.name == :initialize
-        mhash[:constructor] = member
-      elsif yard_class.class_attributes[attr_symbol]
-        mhash[:class_attributes][attr_symbol] = yard_class.class_attributes[attr_symbol]
-      elsif yard_class.instance_attributes[attr_symbol]
-        mhash[:instance_attributes][attr_symbol] = yard_class.instance_attributes[attr_symbol]
-      elsif member.scope == :class
-        mhash[:class_methods] << member
-      elsif member.scope == :instance
-        mhash[:instance_methods] << member
-      end
-    end
-    mhash
-  end
-
-  def title
-    title = "\n{anchor:#{yard_class.name}}\n"
-    title << "h3. Class #{yard_class.path}"
-    title
-  end
-
-  def description
-    description = "\nh4. Description\n\n"
-    description << @description
-    description
-  end
-
-  def model
-    model = "\nh4. Data Model\n\n"
-    model << @model
-    model
-  end
-
-  def xml_example
-    xml_example = String.new
-    if yard_class.docstring.has_tag?('example')
-      xml_example << "\nh4. XML Example\n"
-      xml_example << "{code:lang=xml}\n"
-      filename = yard_class.docstring.tag('example').name.split(/[:)}]/)[2]
-      example = IO.read(File.join(@@rootpath, filename))
-      xml_example << example
-      xml_example << "{code}\n"
-    end
-    xml_example
-  end
-
-  def instance_attributes_table(mode=:all)
-    table = String.new
-    table <<  "\\\\\n||XML Element||Ruby Class||Inherits From||\n"
-    table << "|#{xml_tag}|[##{class_name}]|#{yard_class.superclass}|\n"
-    table << "\\\\\n||XML Child Node||Ruby Attribute||Data Type||Description||\n"
-    xml_names = xml_name_hash
-    @mhash[:instance_attributes].values.each do |attribute|
-      read = attribute[:read]
-      return_tag = read.docstring.tag(:return)
-      ruby_name = read.name.to_s
-      xml_name = xml_names[ruby_name] ? xml_names[ruby_name] : "-"
-      data_type = return_tag.types[0]
-      description = confluence_translate(return_tag.text.gsub(/\n/, ' '))
-      table_row = "|#{xml_name}|#{ruby_name}|#{data_type}|#{description.gsub(/\|/, '\\|')}|\n"
-      case mode
-        when :xml
-          if  xml_name != '-'
-            table << table_row
-          end
-        when :ruby
-          if  xml_name == '-'
-            table << table_row
-          end
-        else
-          table << table_row
-      end
-    end
-    table
-  end
-
-  def xml_name_hash
-    xml_name_hash = Hash.new
-    if @ruby_class.respond_to?(:attributes)
-      @ruby_class.attributes.each do |attribute|
-        xml_name_hash[attribute.name.to_s] = "@#{attribute.tag}"
-      end
-    end
-    if @ruby_class.respond_to?(:elements)
-      @ruby_class.elements.each do |element|
-        if element.options.size == 0 or element.options[:single]
-          xml_name_hash[element.name.to_s] = "<#{element.tag}>"
-        else
-          xml_name_hash[element.name.to_s] = "<#{element.tag}> \\[1..\\*]"
-        end
-      end
-    end
-    xml_name_hash
-  end
-
-  def methods_documentation
-
-    methods_documentation = String.new
-    
-    #methods_documentation ""
-    #methods_documentation "h4. Constructor"
-    #method = mhash[:constructor]
-    #methods_documentation_method(method, yard_class) if method
-
-    methods =mhash[:class_methods]
-    if methods.size > 0
-      methods_documentation << "\nh4. Class Methods\n"
-      methods.each do |method|
-        methods_documentation << method_documentation(method)
-      end
-    end
-
-    methods =mhash[:instance_methods]
-    if methods.size > 0
-      public_methods = Array.new
-      methods.each do |method|
-        if method.docstring.has_tag?(:api) && method.docstring.tag(:api).text == 'external'
-          public_methods << method
-        end
-      end
-      if public_methods.size > 0
-        methods_documentation << "\nh4. Instance Methods\n"
-        public_methods.each do |method|
-          methods_documentation << method_documentation(method)
-        end
-      end
-    end
-    methods_documentation
-  end
-
-  def method_documentation(method)
-
-    method_documentation = String.new
-    if method.nil?
-      raise "method is nil"
-    end
-    method_documentation << "\nh5. #{method.path}\n"
-
-    method_documentation << "||Method||Return Type||Description||\n"
-    if method.name == :initialize
-      return_type = @yard_class.name
-      description = 'constructor'
-    else
-      return_tag = method.docstring.tag(:return)
-      if return_tag.nil?
-        raise "#{method.name} return tag is nil"
-      end
-      return_type = return_tag.types[0]
-      description = confluence_translate(return_tag.text.gsub(/\n/, ' '))
-    end
-    method_documentation << "|#{method.name}|#{return_type}|#{example.description}|\n"
-
-    if method.respond_to?(:docstring)
-      params = method.docstring.tags(:param)
-      if params && params.size > 0
-        method_documentation << "\n||Parameter||Data Type||Description||\n"
-        params.each do |p|
-          description = confluence_translate(p.text.gsub(/\n/, ' '))
-          method_documentation << "|#{p.name}|#{p.types.join(', ')}|#{example.description}|\n"
-        end
-      end
-    end
-
-    method_documentation << "{code:lang=none|title=Ruby Source Code}\n"
-    method_documentation << method.source
-    method_documentation << "{code}\n"
-
-    if method.docstring.has_tag?('example')
-      method_documentation << "\n{code:lang=none|title=Usage Example}\n"
-      filename = method.docstring.tag('example').name.split(/[:)}]/)[2]
-      example = IO.read(File.join(@@rootpath, filename))
-      method_documentation << example
-      method_documentation << "{code}\n"
-    end
-    method_documentation
-  end
-
-  def confluence_translate(input)
-    map = Hash.new
-    map[/\|/] = "\\|"
-    map[/====/] = "h4. "
-    map[/\*/] = "\\*"
-    map[/\n\s{6}\\\*\s/] = "\n****\s"
-    map[/\n\s{4}\\\*\s/] = "\n***\s"
-    map[/\n\s{2}\\\*\s/] = "\n**\s"
-    map[/\n\\\*\s/] = "\n*\s"
-    map[/<[\/]*b>/] = "*"
-    map[/<[\/]*i>/] = "_"
-    map[/\[/] = "\\["
-    map[/\{#/] = "[#"
-    map[/\{http/] = "[http"
-    map[/\{/] = "[#"
-    map[/\}/] = "]"
-    output = input
-    map.each do |regex, replacement|
-      output.gsub!(regex, replacement)
-    end
-    output
-  end
-
-end
-
-
-class ApiDoc < ApiClass
-  attr_accessor :ios
-  attr_accessor :classes
-
-  def process_doc(ios)
-    @ios = ios
-    parse_model
-
-    output component
-    output model
-    output description
-    output xml_example
-    output xml_nodes
-    classes_detail
-  end
-
-  def component
-    component = "h2. Component:  #{yard_class.name}\n"
-    component
-  end
-
-  def xml_nodes
-    nodes = "\nh4. XML Nodes\n"
-    @classes.each do |cls|
-      nodes << cls.instance_attributes_table(mode=:xml)
-    end
-    nodes
-  end
-
-  def classes_detail
-    @classes.each do |cls|
-      output cls.title
-      output cls.description if cls != self
-      output cls.methods_documentation
-    end
-  end
-
-  def parse_model
-    @classes = Array.new
-    @classes << self
-    if @model
-      model.lines.each do |line|
-        matches = line.scan(/\[#(.*)?\]/)
-        if matches.size > 0
-          match = matches[0][0].split(/\]/)[0]
-          if match != class_name
-            @classes << ApiClass.new(match)
-          end
-        end
-      end
-    end
-
-  end
-
-  def output(string)
-    @ios.puts  string
-  end
-
-
-end
-
-
-class DocGenerator
-
-  def initialize(rootpath)
-    @rootpath = rootpath
-  end
-
-  def generate_docs(apis)
-    temp_pathname = Pathname(@rootpath).join('api', 'temp')
-    ApiClass.class_hash = get_class_hash
-    ApiClass.rootpath = @rootpath
-    apis.each do |api_name|
-      doc_pathname = temp_pathname.join(api_name + "_confluence.txt")
-      doc_pathname.parent.mkpath
-      #puts doc_pathname.to_s
-      #unless doc_pathname.exist?
-        begin
-          @constructor_params = Array.new
-          @indent = 0
-          ios = doc_pathname.open("w")
-          api_doc = ApiDoc.new(api_name)
-          api_doc.process_doc(ios)
-        ensure
-          ios.close
-        end
-      #end
-    end
-  end
-
-  def get_class_hash()
-    class_hash = Hash.new
-    yardoc = File.join(@rootpath, '.yardoc')
-    Registry.load!(yardoc) # loads all objects into memory
-    class_array = Registry.all(:class) # Array
-    class_array.each do |cls|
-      class_hash[cls.name.to_s] = cls
-    end
-    class_hash
-  end
-
-end
-
-apis = Array.new
-apis << 'FileInventory'
-apis << 'SignatureCatalog'
-apis << 'FileInventoryDifference'
-apis << 'VersionMetadata'
-apis << 'Serializable'
-apis << 'StorageObject'
-apis << 'StorageRepository'
-apis << 'DorMetadata'
-
-sg = DocGenerator.new(File.expand_path(File.join(File.dirname(__FILE__), '..', '..')))
-sg.generate_docs(apis)

data/lib/tools/spec_generator.rb

@@ -1,409 +0,0 @@
-require 'rubygems'
-require 'pathname'
-require 'yard'
-include YARD
-
-class String
-  def snake_case
-    self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-        gsub(/([a-z\d])([A-Z])/, '\1_\2').
-        tr("-", "_").
-        downcase
-  end
-end
-
-class Symbol
-  def snake_case
-    self.to_s.snake_case
-  end
-end
-
-class SpecGenerator
-
-  def initialize(rootpath)
-    @rootpath = rootpath
-    @ios = $stdout
-  end
-
-  def generate_tests
-    spec_pathname = Pathname(@rootpath).join('spec', 'temp', "temp_unit_tests")
-    classes = get_classes
-    classes.each do |cls|
-      test_pathname = spec_pathname.join(cls.path.snake_case + "_spec.rb")
-      test_pathname.parent.mkpath
-      #puts test_pathname.to_s
-      unless test_pathname.exist?
-        begin
-          @constructor_params = Array.new
-          @indent = 0
-          @ios = test_pathname.open("w")
-          process_class(cls)
-        ensure
-          @ios.close
-        end
-      end
-    end
-  end
-
-  def get_classes()
-    yardoc = File.join(@rootpath, '.yardoc')
-    Registry.load!(yardoc) # loads all objects into memory
-    Registry.all(:class) # Array
-  end
-
-  # @param string [String]
-  def output(string)
-    @ios.puts "  "*@indent + string
-  end
-
-  # @param cls [CodeObjects::ClassObject]
-  def process_class(cls)
-    output %q{require File.join('..', '..','spec_helper')}
-    output ""
-    output "# Unit tests for class {#{cls.path}}"
-    output "describe '#{cls.path}' do"
-    @indent += 1
-    mhash = categorize_members(cls)
-    if mhash[:class_attributes].size > 0
-      process_attributes(cls, :class, mhash[:class_attributes])
-    end
-    if mhash[:class_methods].size > 0
-      process_methods(cls, :class, mhash)
-    end
-
-    process_constructor(cls, mhash)
-
-    if mhash[:instance_attributes].size > 0
-      process_attributes(cls, :instance, mhash[:instance_attributes])
-    end
-    if mhash[:instance_methods].size > 0
-      process_methods(cls, :instance, mhash)
-    end
-
-    @indent -= 1
-    output ""
-    output "end"
-  end
-
-  # @param cls [CodeObjects::ClassObject]
-  def categorize_members(cls)
-    mhash = {
-        :class_attributes => Hash.new,
-        :instance_attributes => Hash.new,
-        :class_methods => Array.new,
-        :instance_methods => Array.new
-    }
-    cls.children.each do |member|
-      attr_symbol = member.name.to_s.gsub(/=$/, '').to_sym
-      if member.name == :initialize
-        mhash[:constructor] = member
-      elsif cls.class_attributes[attr_symbol]
-        mhash[:class_attributes][attr_symbol] = cls.class_attributes[attr_symbol]
-      elsif member.name.to_s[0..1] == '@@'
-        #mhash[:class_attributes][attr_symbol] = cls.class_attributes[attr_symbol]
-      elsif cls.instance_attributes[attr_symbol]
-        mhash[:instance_attributes][attr_symbol] = cls.instance_attributes[attr_symbol]
-      elsif not member.respond_to?(:scope)
-        #puts 'huh?'
-      elsif member.scope == :class
-        mhash[:class_methods] << member
-      elsif member.scope == :instance
-        mhash[:instance_methods] << member
-      end
-    end
-    mhash
-  end
-
-  def process_constructor(cls, mhash)
-    output ""
-    output "describe '=========================== CONSTRUCTOR ===========================' do"
-
-    @indent += 1
-    method = mhash[:constructor]
-    if method.respond_to?(:docstring)
-      @constructor_params = method.docstring.tags(:param)
-
-      output ""
-      output "# Unit test for constructor: {#{method.path}}"
-      output "# Which returns an instance of: [#{cls.path}]"
-      output "# For input parameters:"
-      @constructor_params.each do |p|
-        output "# * #{p.name} [#{p.types.join(', ')}] = #{p.text.gsub(/\n/, ' ')} "
-      end
-      output "specify '#{method.path}' do"
-      @indent += 1
-
-      cls_instance = cls.name.snake_case
-      param_list = (@constructor_params.collect { |p| p.name }).join(', ')
-
-      output " "
-      output "# test initialization with required parameters (if any)"
-      @constructor_params.each do |p|
-        if p.name == 'opts'
-          output "opts = {}"
-        else
-          output "#{p.name} = #{value_for(p.name, p.types[0])} "
-        end
-      end
-      output "#{cls_instance} = #{cls.name}.new(#{param_list})"
-      output "#{cls_instance}.should be_instance_of(#{cls.name})"
-      @constructor_params.each do |p|
-        unless p.name == 'opts'
-          output "#{cls_instance}.#{p.name}.should == #{p.name}"
-        end
-      end
-
-      arrays_and_hashes = attribute_arrays_and_hashes(mhash)
-      if arrays_and_hashes.size > 0
-        output " "
-        output "# test initialization of arrays and hashes"
-        arrays_and_hashes.each do |attr_name, type|
-          output "#{cls_instance}.#{attr_name}.should be_kind_of(#{type})"
-        end
-      end
-
-      @constructor_params.each do |p|
-        if p.name == 'opts'
-          output " "
-          output "# test initialization with options hash"
-          output "opts = Hash.new"
-          attribute_name_type_pairs(mhash).each do |name, type|
-            output "opts[:#{name}] = #{value_for(name, type)}"
-          end
-          output "#{cls_instance} = #{cls.name}.new(#{param_list})"
-          attribute_name_type_pairs(mhash).each do |name, type|
-            output "#{cls_instance}.#{name}.should == opts[:#{name}]"
-          end
-        end
-      end
-
-      output_source(method)
-      @indent -= 1
-
-      output "end"
-
-    end
-    @indent -= 1
-    output ""
-    output "end"
-  end
-
-  def process_attributes(cls, scope, attributes)
-    output ""
-    output "describe '=========================== #{scope.to_s.upcase} ATTRIBUTES ===========================' do"
-    @indent += 1
-
-    if scope == :instance
-      output ""
-      output "before(:all) do"
-      @indent += 1
-      @constructor_params.each do |p|
-        if p.name == 'opts'
-          output "opts = {}"
-        else
-          output "#{p.name} = #{value_for(p.name, p.types[0])} "
-        end
-      end
-      cls_instance = cls.name.snake_case
-      param_list = (@constructor_params.collect { |p| p.name }).join(', ')
-      output "@#{cls_instance} = #{cls.name}.new(#{param_list})"
-      @indent -= 1
-      output "end"
-    end
-
-    attributes.values.each do |attribute|
-      if attribute.nil?
-        puts "huh?"
-      end
-      write = attribute[:write]
-      read = attribute[:read]
-      return_tag = read.docstring.tag(:return)
-      return_type = return_tag.types[0]
-      output ""
-      output "# Unit test for attribute: {#{read.path}}"
-      output "# Which stores: [#{return_type}] #{return_tag.text.gsub(/\n/, ' ')}"
-      output "specify '#{read.path}' do"
-
-      @indent += 1
-      output "value = #{value_for(read.name, return_type)}"
-      case scope
-        when :class
-          output "#{write.path} value"
-          output "#{read.path}.should == value"
-        when :instance
-          output "@#{cls.name.snake_case}.#{write.name} value"
-          output "@#{cls.name.snake_case}.#{read.name}.should == value"
-      end
-
-      output_source(write)
-      output_source(read)
-
-      @indent -= 1
-      output "end"
-    end
-    @indent -= 1
-
-    output ""
-    output "end"
-  end
-
-  def process_methods(cls, scope, mhash)
-    output ""
-    output "describe '=========================== #{scope.to_s.upcase} METHODS ===========================' do"
-    @indent += 1
-
-    if scope == :instance
-      output ""
-      output "before(:each) do"
-      @indent += 1
-      @constructor_params.each do |p|
-        if p.name == 'opts'
-          output "@opts = {}"
-        else
-          output "@#{p.name} = #{value_for(p.name, p.types[0])} "
-        end
-      end
-      cls_instance = cls.name.snake_case
-      param_list = (@constructor_params.collect { |p| '@'+p.name }).join(', ')
-      output "@#{cls_instance} = #{cls.name}.new(#{param_list})"
-      output ""
-      attribute_name_type_pairs(mhash).each do |name, type|
-        output "@#{cls_instance}.#{name} = #{value_for(name, type)}"
-      end
-      @indent -= 1
-      output "end"
-    end
-
-    case scope
-      when :class
-        methods =mhash[:class_methods]
-      when :instance
-        methods =mhash[:instance_methods]
-    end
-
-    methods.each do |method|
-      begin
-        return_tag = method.docstring.tag(:return)
-        return_type = return_tag.types[0]
-
-
-        params = method.docstring.tags(:param)
-
-        output ""
-        output "# Unit test for method: {#{method.path}}"
-        output "# Which returns: [#{return_type}] #{return_tag.text.gsub(/\n/, ' ')}"
-        if params.length > 0
-          output "# For input parameters:"
-          params.each do |p|
-            output "# * #{p.name} [#{p.types.join(', ')}] = #{p.text.gsub(/\n/, ' ')} "
-          end
-        else
-          output "# For input parameters: (None)"
-        end
-
-        output "specify '#{method.path}' do"
-
-        @indent += 1
-        params.each do |p|
-          output "#{p.name} = #{value_for(p.name, p.types[0])} "
-        end
-        param_list = (params.collect { |p| p.name }).join(', ')
-        if return_type == 'void'
-          case scope
-            when :class
-              output "#{method.path}(#{param_list})"
-            when :instance
-              output "@#{cls.name.snake_case}.#{method.name}(#{param_list})"
-          end
-        else
-          case scope
-            when :class
-              output "#{method.path}(#{param_list}).should == "
-            when :instance
-              output "@#{cls.name.snake_case}.#{method.name}(#{param_list}).should == "
-          end
-        end
-
-        output_source(method)
-        @indent -= 1
-
-        output "end"
-
-      rescue Exception => e
-        raise "Error processing method: #{method.path} - " + e.message
-        e.backtrace
-      end
-    end
-    @indent -= 1
-
-    output ""
-    output "end"
-  end
-
-
-  def value_for(name, return_type)
-    case return_type
-      when 'Symbol'
-        ":test_#{name}"
-      when 'Integer'
-        rand(100).to_s
-      when 'String'
-        "'Test #{name}'"
-      when 'Boolean'
-        "true"
-      when 'Pathname'
-        "Pathname.new('/test/#{name}')"
-      when 'Time'
-        "Time.now"
-      else
-        type = return_type.split(/[<>]/)
-        if type.length > 1
-          case type[0]
-            when 'Array'
-              "[#{value_for(name, type[1])}]"
-            when 'Hash'
-              key, value = type[1].split(/[,]/)
-              "{#{value_for(name, key)} => #{value_for(name, value)}}"
-            else
-              "double(#{return_type}.name)"
-          end
-        else
-          "double(#{return_type}.name)"
-        end
-    end
-  end
-
-  def attribute_arrays_and_hashes(mhash)
-    arrays_and_hashes = Hash.new
-    attribute_name_type_pairs(mhash).each do |name, type|
-      if type.include?('Array')
-        arrays_and_hashes[name] = 'Array'
-      elsif type.include?('Hash')
-          arrays_and_hashes[name] = 'Hash'
-      end
-    end
-    arrays_and_hashes
-  end
-
-  def attribute_name_type_pairs(mhash)
-    pairs = Hash.new
-    mhash[:instance_attributes].values.each do |attribute|
-      read = attribute[:read]
-      return_tag = read.docstring.tag(:return)
-      pairs[read.name] =return_tag.types[0]
-    end
-    pairs
-  end
-
-  def output_source(method)
-    output " "
-    lines = method.source.split(/\n/)
-    lines.each { |line| output "# #{line}" }
-  end
-
-end
-
-
-sg = SpecGenerator.new(File.expand_path(File.join(File.dirname(__FILE__), '..', '..')))
-sg.generate_tests

data/lib/tools/spec_generator_old.rb

@@ -1,49 +0,0 @@
-rootpath = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-puts rootpath
-lib = File.join(rootpath,'lib')
-$LOAD_PATH.unshift(lib)  unless $LOAD_PATH.include?(lib)
-require 'moab'
-#spec_helper = File.join(rootpath,'spec','spec_helper')
-
-class SpecGeneratorOld
-
-  attr_accessor :c
-  attr_accessor :members
-
-  def initialize(c)
-    @c=c
-    #require camel_to_snake_case(c.name)
-    i_members = c.instance_methods(include_super=false)
-    i_setters = i_members.grep /[^=][=]$/
-    i_getters = i_setters.collect { |s| s.gsub(/[=]$/,'') }
-    @members = Hash.new
-    @members['Instance Variables'] = (i_getters).sort
-    @members['Instance Methods'] = (i_members - i_setters - i_getters).sort
-    @members['Class Methods'] = c.methods(include_super=false).sort
-  end
-
-  def generate
-    puts "require 'spec_helper'"
-    puts ""
-    puts "describe '#{@c.name}' do"
-    puts ""
-    ['Instance Variables','Instance Methods','Class Methods'].each do |type |
-      puts "  context '#{type}' do"
-      puts ""
-      @members[type].each do |member|
-        puts "    describe '##{member}' do"
-        puts "      pending"
-        puts "    end"
-        puts ""
-      end
-      puts "  end"
-      puts ""
-    end
-    puts "end"
-  end
-
-  def camel_to_snake_case(camel)
-    camel.gsub(/(.)([A-Z])/,'\1_\2').downcase
-  end
-
-end