social_snippet 0.0.9 → 0.0.10

data/lib/social_snippet/resolvers/base_resolver.rb

@@ -32,7 +32,6 @@ module SocialSnippet
           move_context_by_tag! new_context, t
           overwrite_tag_in_same_repository! new_context, t
           update_tag_path_by_context! new_context, t
-          resolve_tag_repo_ref! t
         end
 
         resolve_tag_repo_ref! t
@@ -47,13 +46,6 @@ module SocialSnippet
 
     private
 
-    def resolve_tag_repo_ref!(t)
-      if t.has_repo?
-        repo = core.repo_manager.find_repository_by_tag(t)
-        t.set_ref repo.latest_version(t.ref)
-      end
-    end
-
     def move_context_by_tag!(context, tag)
       if tag.has_repo?
         if tag.has_ref?
@@ -83,16 +75,20 @@ module SocialSnippet
 
     # Resolve tag's ref
     def resolve_tag_repo_ref!(tag)
-      repo = core.repo_manager.find_repository_by_tag(tag)
-
-      # not found
-      return if repo.nil?
-
-      if tag.has_ref? === false || tag.ref != repo.latest_version(tag.ref)
-        if repo.has_versions?
-          tag.set_ref repo.latest_version(tag.ref)
+      return unless tag.has_repo?
+      repo = core.repo_manager.find_repository(tag.repo)
+      # set latest version
+      if tag.has_ref? === false
+        if repo.has_package_versions?
+          tag.set_ref repo.latest_package_version
         else
-          tag.set_ref repo.short_commit_id
+          tag.set_ref repo.current_ref
+        end
+      else
+        unless repo.has_ref?(tag.ref)
+          new_ref = repo.latest_version(tag.ref)
+          raise "error" if new_ref.nil?
+          tag.set_ref new_ref
         end
       end
     end

data/lib/social_snippet/rspec/test_document.rb

@@ -0,0 +1,305 @@
+RSpec.configure do
+
+  shared_context :TestDocument do
+
+    class TestDocument1 < ::SocialSnippet::Document
+      field :field_string, :type => String
+      field :field_array, :type => Array, :default => ::Array.new
+      field :field_hash, :type => Hash, :default => ::Hash.new
+    end
+
+    class TestDocument2 < ::SocialSnippet::Document
+      field :field_string, :type => String
+      field :field_array, :type => Array, :default => ::Array.new
+      field :field_hash, :type => Hash, :default => ::Hash.new
+    end
+
+    describe "find by regexp" do
+
+      context "create items" do
+
+        before do
+          TestDocument1.create :field_string => "a"
+          TestDocument1.create :field_string => "A"
+          TestDocument1.create :field_string => "abc"
+          TestDocument1.create :field_string => "b"
+          TestDocument1.create :field_string => "bc"
+          TestDocument1.create :field_string => "c"
+        end
+
+        context "where /^a/" do
+
+          let(:result) { TestDocument1.where :field_string => /^a/ }
+
+          context "map result" do
+            subject do
+              result.map {|item| item.field_string }
+            end
+            it { should include "a" }
+            it { should_not include "A" }
+            it { should include "abc" }
+            it { should_not include "b" }
+            it { should_not include "bc" }
+            it { should_not include "c" }
+          end
+
+        end
+
+      end
+
+    end # find by regexp
+
+    describe "#add_to_set" do
+
+      context "create item" do
+
+        let(:item) { TestDocument2.create }
+        it { expect(item.field_array).to be_empty }
+
+        context "add_to_set value" do
+
+          before { item.add_to_set :field_array => "value" }
+          it { expect(item.field_array.length).to eq 1 }
+          it { expect(item.field_array).to include "value" }
+
+          context "add_to_set new_value" do
+
+            before { item.add_to_set :field_array => "new-value" }
+            it { expect(item.field_array.length).to eq 2 }
+            it { expect(item.field_array).to include "value" }
+            it { expect(item.field_array).to include "new-value" }
+
+            context "add_to_set value (duplicated value)" do
+
+              before { item.add_to_set :field_array => "value" }
+              it { expect(item.field_array.length).to eq 2 }
+              it { expect(item.field_array).to include "value" }
+              it { expect(item.field_array).to include "new-value" }
+
+              context "find item.id" do
+
+                let(:found_item) { TestDocument2.find(item.id) }
+                it { expect(item.field_array.length).to eq 2 }
+                it { expect(item.field_array).to include "value" }
+                it { expect(item.field_array).to include "new-value" }
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end #add_to_set
+
+    describe "#update_attributes!" do
+
+      context "create item" do
+        let(:item) { TestDocument1.create :field_string => "value" }
+        subject { item.field_string }
+        it { should eq "value" }
+        context "find item.id" do
+          subject { TestDocument1.find item.id }
+          it { expect(subject.field_string).to eq "value" }
+        end
+        context "item.update_attributes! field_string => new-value" do
+          before { item.update_attributes! :field_string => "new-value" }
+          it { should eq "new-value" }
+          context "find item.id" do
+            subject { TestDocument1.find item.id }
+            it { expect(subject.field_string).to eq "new-value" }
+          end
+        end
+      end
+
+    end
+
+    describe "#push" do
+
+      context "create item" do
+
+        let(:item) { TestDocument1.create }
+        it { expect(item.field_array).to be_empty }
+
+        context "push item" do
+
+          before { item.push :field_array => "val" }
+          it { expect(item.field_array).to_not be_empty }
+          it { expect(item.field_array).to include "val" }
+
+          context "pull item" do
+
+            before { item.pull :field_array => "val" }
+            it { expect(item.field_array).to be_empty }
+
+          end
+
+        end
+
+      end
+
+    end #push
+
+    describe "#count" do
+
+      subject { TestDocument1.count }
+      it { should eq 0 }
+
+      context "create a item" do
+
+        before { TestDocument1.create(:field_string => "item") }
+        it { should eq 1 }
+
+        context "find_or_create_by item" do
+
+          before { TestDocument1.find_or_create_by(:field_string => "item") }
+          it { should eq 1 }
+
+          context "create another item" do
+            before { TestDocument1.create(:field_string => "item") }
+            it { should eq 2 }
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#exists?" do
+
+      subject { TestDocument1.exists? }
+      it { should be_falsey }
+
+      context "TestDocument2.exists?" do
+        subject { TestDocument2.exists? }
+        it { should be_falsey }
+      end
+
+      context "create a item" do
+
+        before { TestDocument1.create(:field_string => "item1") }
+        it { should be_truthy }
+
+        context "TestDocument2.exists?" do
+          subject { TestDocument2.exists? }
+          it { should be_falsey }
+        end
+
+      end # create a item
+
+    end #exists?
+
+    describe "#find_by" do
+
+      context "find_or_create_by :field_string => abc" do
+
+        before do
+          doc = TestDocument1.find_or_create_by(:field_string => "abc")
+          doc.field_array.push "val1"
+          doc.field_array.push "val2"
+          doc.field_array.push "val3"
+          doc.field_hash["key"] = "val"
+          doc.save!
+        end
+
+        context "find_by :field_string => abc" do
+          let(:item) { TestDocument1.find_by :field_string => "abc" }
+          it { expect(item.field_string).to eq "abc" }
+          it { expect(item.field_array.length).to eq 3 }
+          it { expect(item.field_array).to include "val1" }
+          it { expect(item.field_array).to include "val2" }
+          it { expect(item.field_array).to include "val3" }
+          it { expect(item.field_hash["key"]).to include "val" }
+        end
+
+        context "find_by :field_string => not_found" do
+          subject do
+            lambda { TestDocument1.find_by :field_string => "not_found" }
+          end
+          it { should raise_error }
+        end
+
+      end
+
+    end #find_by
+
+    describe "test field" do
+
+      let(:doc) do
+        TestDocument1.new
+      end
+
+      context "doc.field_string = test" do
+        before { doc.field_string = "test" }
+        it { expect(doc.field_string).to eq "test" }
+      end
+
+      context "doc.field_array.push item" do
+        before { doc.field_array.push "item" }
+        it { expect(doc.field_array).to include "item" }
+      end
+
+      context "doc.field_hash[key] = value" do
+        before { doc.field_hash["key"] = "value" }
+        it { expect(doc.field_hash["key"]).to eq "value" }
+      end
+
+    end # test field
+
+    describe "test persistence" do
+
+      context "create item" do
+
+        before do
+          item = TestDocument1.create(:id => "item")
+          item.field_string = "this is string"
+          item.field_array.push "this is array"
+          item.field_hash["key"] = "this is hash"
+          item.save!
+        end
+
+        context "check existance" do
+          context "TestDocument1.where(:id => item).exists?" do
+            subject { TestDocument1.where(:id => "item").exists? }
+            it { should be_truthy }
+          end
+          context "TestDocument2.where(:id => item).exists?" do
+            subject { TestDocument2.where(:id => "item").exists? }
+            it { should be_falsey }
+          end
+        end
+
+        context "find item" do
+          context "in document-1" do
+            subject { TestDocument1.find "item" }
+            it { expect(subject.field_string).to eq "this is string" }
+            it { expect(subject.field_array).to include "this is array" }
+            it { expect(subject.field_hash["key"]).to eq "this is hash" }
+          end
+          context "in document-2" do
+            example do
+              expect { TestDocument2.find "item" }.to raise_error
+            end
+          end
+        end
+
+        context "remove item" do
+          before { TestDocument1.find("item").remove }
+          context "re-find item" do
+            subject { TestDocument1.where(:id => "item").exists? }
+            it { should be_falsey }
+          end
+        end
+
+      end # create item
+
+    end # test persistence
+
+  end # [shared] TestDocument
+
+end
+

data/lib/social_snippet/rspec/test_driver.rb

@@ -0,0 +1,76 @@
+RSpec.configure do
+
+  # need to set let(:driver_class) { ... }
+  shared_context :TestDriver do
+
+    describe "test driver class", :without_fakefs => true do
+
+      context "handle github repo" do
+
+        let(:repo_url) { "git://github.com/social-snippet/example-repo.git" }
+
+        subject(:driver) do
+          driver_class.new repo_url
+        end
+
+        context "driver.fetch" do
+
+          before { driver.fetch }
+
+          describe "#each_file" do
+            context "get files" do
+              let(:files) { ::Hash.new }
+              before do
+                driver.each_file("1.0.2") do |file|
+                  files[file.path] = file.data
+                end
+              end
+              context "check files" do
+                subject { files }
+                it { should include "README.md" }
+                it { should include "snippet.json" }
+                it { should include "src/func.cpp" }
+                it { should include "src/func/sub_func_1.cpp" }
+                it { should include "src/func/sub_func_2.cpp" }
+                it { should include "src/func/sub_func_3.cpp" }
+                it { expect(files["snippet.json"]).to match "example-repo" }
+                it { expect(files["src/func/sub_func_1.cpp"]).to match "int sub_func_1()" }
+              end
+            end
+          end
+
+          describe "#refs" do
+            subject { driver.refs }
+            it { should include "master" }
+            it { should include "1.0.0" }
+            it { should include "1.0.1" }
+          end #refs
+
+          describe "#versions" do
+            subject { driver.versions }
+            it { should_not include "master" }
+            it { should include "1.0.0" }
+            it { should include "1.0.1" }
+          end #versions
+
+          describe "#latest_version" do
+            context "latest_version 1.0" do
+              subject { driver.latest_version("1.0") }
+              it { should eq "1.0.2" }
+            end
+            context "latest_version 9.9" do
+              subject { driver.latest_version("9.9") }
+              it { should eq nil }
+            end
+          end #latest_version
+
+        end # driver.fetch
+
+      end # github repo
+
+    end # 
+
+  end # [shared] TestDriver
+
+end
+

data/lib/social_snippet/rspec/test_storage.rb

@@ -0,0 +1,459 @@
+RSpec.configure do
+
+  shared_context :TestStorage do
+
+    describe "test storage class" do
+
+      let(:storage) { ::SocialSnippet::Storage.new }
+
+      describe "no entry" do
+
+        context "read not_found.txt" do
+          subject do
+            lambda { storage.read "not_found.txt" }
+          end
+          it { should raise_error ::Errno::ENOENT }
+        end
+
+        context "rm path/to/not_found" do
+          subject do
+            lambda { storage.rm "path/to/not_found.txt" }
+          end
+          it { should raise_error ::Errno::ENOENT }
+        end
+
+        context "touch not_found/path/to/file" do
+          subject do
+            lambda { storage.touch "not_found/path/to/file" }
+          end
+          it { should raise_error ::Errno::ENOENT }
+        end
+
+        context "rm_r path/to/not_found" do
+          subject do
+            lambda { storage.rm_r "path/to/not_found" }
+          end
+          it { should raise_error ::Errno::ENOENT }
+        end
+
+        context "cd path/to/not_found" do
+          subject do
+            lambda { storage.cd "path/to/not_found" }
+          end
+          it { should raise_error ::Errno::ENOENT }
+        end
+
+        context "prepare file" do
+          before do
+            storage.mkdir_p "path/to"
+            storage.touch "path/to/file"
+          end
+          context "cd path/to/file" do
+            subject do
+              lambda { storage.cd "path/to/file"; p storage.pwd; p storage.file?(storage.pwd) }
+            end
+            # TODO: it { should raise_error ::Errno::ENOTDIR }
+          end
+        end
+
+      end # no entry
+
+      describe "#glob" do
+
+        context "prepare storage" do
+
+          before do
+            storage.mkdir_p "/path/to/dir1"
+            storage.mkdir_p "/path/to/dir2"
+            storage.mkdir_p "/path/to/dir2/subdir1"
+            storage.mkdir_p "/path/to/dir2/subdir2"
+            storage.mkdir_p "/path/to/dir3"
+            storage.touch "/path/to/file1.c"
+            storage.touch "/path/to/dir1/file2.c"
+            storage.touch "/path/to/dir1/file3.c"
+            storage.touch "/path/to/dir2/file4.rb"
+            storage.touch "/path/to/dir2/file5.c"
+            storage.touch "/path/to/dir3/file6.cpp"
+            storage.touch "/path/to/dir2/subdir1/file7.c"
+            storage.touch "/path/to/dir2/subdir2/file8.rb"
+          end
+
+          context "glob /path/to/dir1" do
+            subject { storage.glob "/path/to/dir1" }
+            it { expect(subject.length).to eq 1 } 
+            it { should include "/path/to/dir1" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should_not include "/path/to/file1.c" }
+          end
+
+          context "glob /path/to/*.c" do
+            subject { storage.glob "/path/to/*.c" }
+            it { expect(subject.length).to eq 1 } 
+            it { should_not include "/path/to/" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should include "/path/to/file1.c" }
+            it { should_not include "/path/to/dir1/file2.c" }
+            it { should_not include "/path/to/dir1/file3.c" }
+            it { should_not include "/path/to/dir2/file5.c" }
+            it { should_not include "/path/to/dir3/file6.cpp" }
+            it { should_not include "/path/to/dir2/subdir1/file7.c" }
+          end
+
+          context "glob /path/to/**/*.c" do
+            subject { storage.glob "/path/to/**/*.c" }
+            it { expect(subject.length).to eq 5 } 
+            it { should_not include "/path/to/" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should include "/path/to/file1.c" }
+            it { should include "/path/to/dir1/file2.c" }
+            it { should include "/path/to/dir1/file3.c" }
+            it { should include "/path/to/dir2/file5.c" }
+            it { should_not include "/path/to/dir3/file6.cpp" }
+            it { should include "/path/to/dir2/subdir1/file7.c" }
+          end
+
+          context "glob /path/to/dir2/**/*.c" do
+            subject { storage.glob "/path/to/dir2/**/*.c" }
+            it { expect(subject.length).to eq 2 } 
+            it { should_not include "/path/to/" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should_not include "/path/to/file1.c" }
+            it { should_not include "/path/to/dir1/file2.c" }
+            it { should_not include "/path/to/dir1/file3.c" }
+            it { should include "/path/to/dir2/file5.c" }
+            it { should_not include "/path/to/dir3/file6.cpp" }
+            it { should include "/path/to/dir2/subdir1/file7.c" }
+          end
+
+          context "glob /path/to/**/*.cpp" do
+            subject { storage.glob "/path/to/**/*.cpp" }
+            it { expect(subject.length).to eq 1 } 
+            it { should_not include "/path/to/" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should_not include "/path/to/file1.c" }
+            it { should_not include "/path/to/dir1/file2.c" }
+            it { should_not include "/path/to/dir1/file3.c" }
+            it { should_not include "/path/to/dir2/file5.c" }
+            it { should include "/path/to/dir3/file6.cpp" }
+            it { should_not include "/path/to/dir2/subdir1/file7.c" }
+          end
+
+          context "glob /path/to/**/*.rb" do
+            subject { storage.glob "/path/to/**/*.rb" }
+            it { expect(subject.length).to eq 2 } 
+            it { should_not include "/path/to/" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should_not include "/path/to/file1.c" }
+            it { should_not include "/path/to/dir1/file2.c" }
+            it { should_not include "/path/to/dir1/file3.c" }
+            it { should include "/path/to/dir2/file4.rb" }
+            it { should_not include "/path/to/dir2/file5.c" }
+            it { should_not include "/path/to/dir3/file6.cpp" }
+            it { should_not include "/path/to/dir2/subdir1/file7.c" }
+            it { should include "/path/to/dir2/subdir2/file8.rb" }
+          end
+
+          context "glob /path/to/dir2/**/*.rb" do
+            subject { storage.glob "/path/to/dir2/**/*.rb" }
+            it { expect(subject.length).to eq 2 } 
+            it { should_not include "/path/to/" }
+            it { should_not include "/path/to/dir2" }
+            it { should_not include "/path/to/dir3" }
+            it { should_not include "/path/to/file1.c" }
+            it { should_not include "/path/to/dir1/file2.c" }
+            it { should_not include "/path/to/dir1/file3.c" }
+            it { should include "/path/to/dir2/file4.rb" }
+            it { should_not include "/path/to/dir2/file5.c" }
+            it { should_not include "/path/to/dir3/file6.cpp" }
+            it { should_not include "/path/to/dir2/subdir1/file7.c" }
+            it { should include "/path/to/dir2/subdir2/file8.rb" }
+          end
+
+        end
+
+      end #glob
+
+      describe "change workdir" do
+
+        let!(:root_dir) { storage.pwd }
+
+        context "mkdir path/to/dir" do
+
+          subject { storage.pwd }
+
+          before { storage.mkdir_p "path/to/dir" }
+
+          context "cd path/to" do
+
+            before { storage.cd "path/to" }
+            it { should eq ::File.join(root_dir, "path", "to") }
+
+            context "cd ../" do
+
+              before { storage.cd "../" }
+              it { should eq ::File.join(root_dir, "path") }
+
+              context "storage.cd ./" do
+
+                before { storage.cd "./" }
+                it { should eq ::File.join(root_dir, "path") }
+
+                context "storage.cd ./to/dir" do
+                  before { storage.cd "to/dir" }
+                  it { should eq ::File.join(root_dir, "path", "to", "dir") }
+                end
+
+              end
+
+            end
+
+          end
+
+          context "touch path/to/dir/file" do
+            before { storage.touch "path/to/dir/file" }
+            context "cd path/to/dir" do
+              before { storage.cd "path/to/dir" }
+              context "read file" do
+                subject { storage.file? "file" }
+                it { should be_truthy }
+              end
+              context "read file from root" do
+                before { storage.cd root_dir }
+                subject { storage.file? "path/to/dir/file" }
+                it { should be_truthy }
+              end
+            end
+          end
+
+        end # mkdir path/to/dir
+
+        context "mkdir path" do
+
+          before { storage.mkdir "path" }
+
+          context "cd path" do
+
+            before { storage.cd "path" }
+
+            context "mkdir to" do
+
+              before { storage.mkdir "to" }
+
+              context "cd to" do
+
+                before { storage.cd "to" }
+
+                context "mkdir dir" do
+
+                  before { storage.mkdir "dir" }
+
+                  context "cd root" do
+
+                    before { storage.cd root_dir }
+
+                    context "directory? path/to/dir" do
+                      subject { storage.directory? "path/to/dir" }
+                      it { should be_truthy }
+                    end
+
+                  end
+
+                end
+
+                context "write file, data" do
+
+                  before { storage.write "file", "data" }
+
+                  context "cd root" do
+
+                    before { storage.cd root_dir }
+
+                    context "read path/to/file" do
+                      subject { storage.read "path/to/file" }
+                      it { should eq "data" }
+                    end
+
+                  end
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end # change workdir
+
+      describe "duplication" do
+
+        context "mkdir /lib" do
+
+          before { storage.mkdir "/lib" }
+
+          context "touch /lib/entity" do
+
+            before { storage.touch "/lib/entity" }
+
+            context "mkdir /lib/entity" do
+
+              subject do
+                lambda { storage.mkdir "/lib/entity" }
+              end
+
+              it { should raise_error ::Errno::EEXIST }
+
+            end
+
+          end
+
+          context "mkdir /lib/entity" do
+
+            before { storage.mkdir "/lib/entity" } 
+
+            context "touch /lib/entity" do
+
+              subject do
+                lambda { storage.touch "/lib/entity" }
+              end
+
+              it { should_not raise_error }
+
+            end
+
+            context "write /lib/entity, data" do
+
+              subject do
+                lambda { storage.write "/lib/entity", "data" }
+              end
+
+              it { should raise_error ::Errno::EISDIR }
+
+            end
+
+          end
+
+        end # mkdir /lib
+
+      end # duplication
+
+      context "mkdir_p /path/to" do
+
+        before { storage.mkdir_p "/path/to" }
+
+        context "exists? /path/to" do
+          before { storage.exists? "/path/to" }
+          it { should be_truthy }
+        end
+
+        context "file? /path/to" do
+          subject { storage.file? "/path/to" }
+          it { should be_falsey }
+        end
+
+        context "directory? /path/to" do
+          subject { storage.directory? "/path/to" }
+          it { should be_truthy }
+        end
+
+        context "write /path/to/file, data" do
+          before { storage.write "/path/to/file", "data" }
+          context "read /path/to/file" do
+            subject { storage.read "/path/to/file" }
+            it { should eq "data" }
+          end
+        end
+
+        context "touch /path/to/file" do
+
+          before { storage.touch "/path/to/file" }
+
+          context "exists? /path/to/file" do
+            subject { storage.exists? "/path/to/file" }
+            it { should be_truthy }
+          end
+
+          context "file? /path/to/file" do
+            subject { storage.file? "/path/to/file" }
+            it { should be_truthy }
+          end
+
+          context "directory? /path/to/file" do
+            subject { storage.directory? "/path/to/file" }
+            it { should be_falsey }
+          end
+
+          context "rm_r /path/to" do
+
+            before { storage.rm_r "/path/to" }
+
+            context "exists? /path/to" do
+              subject { storage.exists? "/path/to" }
+              it { should be_falsey }
+            end
+
+            context "file? /path/to" do
+              subject { storage.file? "/path/to" }
+              it { should be_falsey }
+            end
+
+            context "directory? /path/to" do
+              subject { storage.directory? "/path/to" }
+              it { should be_falsey }
+            end
+
+            context "exists? /path/to/file" do
+              subject { storage.exists? "/path/to/file" }
+              it { should be_falsey }
+            end
+
+            context "file? /path/to/file" do
+              subject { storage.file? "/path/to/file" }
+              it { should be_falsey }
+            end
+
+            context "directory? /path/to/file" do
+              subject { storage.directory? "/path/to/file" }
+              it { should be_falsey }
+            end
+
+          end
+
+          context "rm /path/to/file" do
+
+            before { storage.rm "/path/to/file" }
+
+            context "exists? /path/to/file" do
+              subject { storage.exists? "/path/to/file" }
+              it { should be_falsey }
+            end
+
+            context "file? /path/to/file" do
+              subject { storage.file? "/path/to/file" }
+              it { should be_falsey }
+            end
+
+            context "directory? /path/to/file" do
+              subject { storage.directory? "/path/to/file" }
+              it { should be_falsey }
+            end
+
+          end # rm /path/to/file
+
+        end # touch /path/to/file
+
+      end # mkdir_p /path/to
+
+    end # test storage class
+
+  end # [shared] TestStorage
+
+end