zip-container 1.1.0 → 2.0.0

data/lib/zip-container/{container.rb → file.rb}

@@ -1,4 +1,4 @@
-# Copyright (c) 2013 The University of Manchester, UK.
+# Copyright (c) 2013, 2014 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -45,14 +45,13 @@ module ZipContainer
   # alongside these pages.
   #
   # There are code examples available with the source code of this library.
-  class Container
+  class File
     include ReservedNames
     include ManagedEntries
 
     extend Forwardable
     def_delegators :@zipfile, :comment, :comment=, :commit_required?, :each,
-      :entries, :extract, :find_entry, :get_entry, :get_input_stream, :glob,
-      :name, :read, :size
+      :entries, :extract, :get_input_stream, :name, :read, :size
 
     private_class_method :new
 
@@ -87,11 +86,11 @@ module ZipContainer
     # :startdoc:
 
     # :call-seq:
-    #   Container.create(filename, mimetype = "application/epub+zip") -> document
-    #   Container.create(filename, mimetype = "application/epub+zip") {|document| ...}
+    #   File.create(filename, mimetype) -> document
+    #   File.create(filename, mimetype) {|document| ...}
     #
     # Create a new ZipContainer file on disk with the specified mimetype.
-    def Container.create(filename, mimetype, &block)
+    def self.create(filename, mimetype, &block)
       ::Zip::OutputStream.open(filename) do |stream|
         stream.put_next_entry(MIMETYPE_FILE, nil, nil, ::Zip::Entry::STORED)
         stream.write mimetype
@@ -112,13 +111,13 @@ module ZipContainer
     end
 
     # :call-seq:
-    #   Container.each_entry -> Enumerator
-    #   Container.each_entry {|entry| ...}
+    #   File.each_entry -> Enumerator
+    #   File.each_entry {|entry| ...}
     #
     # Iterate over the entries in the ZipContainer file. The entry objects
     # returned by this method are Zip::Entry objects. Please see the
     # rubyzip documentation for details.
-    def Container.each_entry(filename, &block)
+    def self.each_entry(filename, &block)
       c = new(filename)
 
       if block_given?
@@ -133,12 +132,12 @@ module ZipContainer
     end
 
     # :call-seq:
-    #   Container.open(filename) -> document
-    #   Container.open(filename) {|document| ...}
+    #   File.open(filename) -> document
+    #   File.open(filename) {|document| ...}
     #
     # Open an existing ZipContainer file from disk. It will be checked for
     # conformance upon first access.
-    def Container.open(filename, &block)
+    def self.open(filename, &block)
       c = new(filename)
 
       if block_given?
@@ -153,12 +152,12 @@ module ZipContainer
     end
 
     # :call-seq:
-    #   Container.verify(filename) -> boolean
+    #   File.verify(filename) -> boolean
     #
     # Verify that the specified ZipContainer file conforms to the
     # specification. This method returns +false+ if there are any problems at
     # all with the file (including if it cannot be found).
-    def Container.verify(filename)
+    def self.verify(filename)
       begin
         new(filename).verify!
       rescue
@@ -169,13 +168,13 @@ module ZipContainer
     end
 
     # :call-seq:
-    #   Container.verify!(filename)
+    #   File.verify!(filename)
     #
     # Verify that the specified ZipContainer file conforms to the
     # specification. This method raises exceptions when errors are found or if
     # there is something fundamental wrong with the file itself (e.g. it
     # cannot be found).
-    def Container.verify!(filename)
+    def self.verify!(filename)
       new(filename).verify!
     end
 
@@ -238,6 +237,40 @@ module ZipContainer
       @fs_file
     end
 
+    # :call-seq:
+    #   find_entry(entry_name, options = {}) -> Zip::Entry or nil
+    #
+    # Searches for the entry with the specified name. Returns +nil+ if no
+    # entry is found or if the specified entry is hidden for normal use. You
+    # can specify <tt>:include_hidden => true</tt> to include hidden entries
+    # in the search.
+    def find_entry(entry_name, options = {})
+      options = {:include_hidden => false}.merge(options)
+
+      unless options[:include_hidden]
+        return if hidden_entry?(entry_name)
+      end
+
+      @zipfile.find_entry(entry_name)
+    end
+
+    # :call-seq:
+    #   get_entry(entry, options = {}) -> Zip::Entry or nil
+    #
+    # Searches for an entry like find_entry, but throws Errno::ENOENT if no
+    # entry is found or if the specified entry is hidden for normal use. You
+    # can specify <tt>:include_hidden => true</tt> to include hidden entries
+    # in the search.
+    def get_entry(entry, options = {})
+      options = {:include_hidden => false}.merge(options)
+
+      unless options[:include_hidden]
+        raise Errno::ENOENT, entry if hidden_entry?(entry)
+      end
+
+      @zipfile.get_entry(entry)
+    end
+
     # :call-seq:
     #   get_output_stream(entry, permission = nil) -> stream
     #   get_output_stream(entry, permission = nil) {|stream| ...}
@@ -256,6 +289,41 @@ module ZipContainer
       @zipfile.get_output_stream(entry, permission, &block)
     end
 
+    # :call-seq:
+    #   glob(pattern) -> Array
+    #   glob(pattern) { |entry| ... }
+    #   glob(pattern, *parameters) -> Array
+    #   glob(pattern, *parameters) { |entry| ... }
+    #
+    # Searches for entries given a glob. Hidden files are ignored by default.
+    #
+    # The parameters that can be supplied are:
+    # * +flags+ - A bitwise OR of the <tt>FNM_xxx</tt> parameters defined in
+    #   File::Constants. The default value is
+    #   <tt>::File::FNM_PATHNAME | ::File::FNM_DOTMATCH</tt>
+    # * +options+ - <tt>:include_hidden => true</tt> will include hidden
+    #   entries in the search.
+    def glob(pattern, *params, &block)
+      flags = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH
+      options = { :include_hidden => false }
+
+      params.each do |param|
+        case param
+        when Hash
+          options = options.merge(param)
+        else
+          flags = param
+        end
+      end
+
+      entries.map do |entry|
+        next if !options[:include_hidden] && hidden_entry?(entry)
+        next unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
+        yield(entry) if block_given?
+        entry
+      end.compact
+    end
+
     # :call-seq:
     #   in_memory? -> boolean
     #

data/lib/zip-container/util.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the names of The University of Manchester nor the names of its
+#    contributors may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: Robert Haines
+
+#
+module ZipContainer
+
+  # Utility methods useful throughout the rest of the ZipContainer library.
+  module Util
+
+    # :call-seq:
+    #   entry_name(entry) -> String
+    #
+    # A lot of methods can take either a String or a Zip::Entry object to
+    # represent an item in a Zip file so this method normalizes these
+    # parameters.
+    #
+    # In common with rubyzip this method also removes a trailing slash (/)
+    # from a name if it can.
+    def entry_name(entry)
+      name = entry.kind_of?(::Zip::Entry) ? entry.name : entry
+
+      if name.respond_to?(:end_with?) && name.respond_to?(:chop!)
+        name.chop! if name.end_with?("/")
+      end
+
+      name
+    end
+
+  end
+end

data/test/helpers/entry_lists.rb

@@ -0,0 +1,35 @@
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the names of The University of Manchester nor the names of its
+#    contributors may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: Robert Haines
+
+def entry_list_names(entries)
+  entries.map { |entry| entry.name }
+end

data/test/tc_create.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2013 The University of Manchester, UK.
+# Copyright (c) 2013, 2014 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -42,7 +42,7 @@ class TestCreation < Test::Unit::TestCase
       filename = File.join(dir, "test.container")
 
       assert_nothing_raised do
-        ZipContainer::Container.create(filename, $mimetype) do |c|
+        ZipContainer::File.create(filename, $mimetype) do |c|
           assert(c.on_disk?)
           refute(c.in_memory?)
 
@@ -50,8 +50,8 @@ class TestCreation < Test::Unit::TestCase
         end
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, Zip::ZipError) do
-        ZipContainer::Container.verify!(filename)
+      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
+        ZipContainer::File.verify!(filename)
       end
     end
   end
@@ -64,7 +64,7 @@ class TestCreation < Test::Unit::TestCase
       filename = File.join(dir, "test.container")
 
       assert_nothing_raised do
-        ZipContainer::Container.create(filename, mimetype) do |c|
+        ZipContainer::File.create(filename, mimetype) do |c|
           assert(c.on_disk?)
           refute(c.in_memory?)
 
@@ -72,8 +72,8 @@ class TestCreation < Test::Unit::TestCase
         end
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, Zip::ZipError) do
-        ZipContainer::Container.verify!(filename)
+      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
+        ZipContainer::File.verify!(filename)
       end
     end
   end
@@ -85,7 +85,7 @@ class TestCreation < Test::Unit::TestCase
       filename = File.join(dir, "test.container")
 
       assert_nothing_raised do
-        ZipContainer::Container.create(filename, $mimetype) do |c|
+        ZipContainer::File.create(filename, $mimetype) do |c|
           assert(c.on_disk?)
           refute(c.in_memory?)
 
@@ -115,8 +115,8 @@ class TestCreation < Test::Unit::TestCase
         end
       end
 
-      assert_nothing_raised(ZipContainer::MalformedContainerError, Zip::ZipError) do
-        ZipContainer::Container.open(filename) do |c|
+      assert_nothing_raised(ZipContainer::MalformedContainerError, ZipContainer::ZipError) do
+        ZipContainer::File.open(filename) do |c|
           assert(c.on_disk?)
           refute(c.in_memory?)
 

data/test/tc_exceptions.rb

@@ -0,0 +1,56 @@
+# Copyright (c) 2014 The University of Manchester, UK.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the names of The University of Manchester nor the names of its
+#    contributors may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: Robert Haines
+
+require 'test/unit'
+require 'zip-container'
+
+class TestExceptions < Test::Unit::TestCase
+
+  def test_rescue_container_errors
+    assert_raise(ZipContainer::ContainerError) do
+      raise ZipContainer::ZipError.new
+    end
+
+    assert_raise(ZipContainer::ContainerError) do
+      raise ZipContainer::MalformedContainerError.new
+    end
+
+    assert_raise(ZipContainer::ContainerError) do
+      raise ZipContainer::ReservedNameClashError.new("test")
+    end
+
+    assert_raise(ZipContainer::ContainerError) do
+      raise Zip::ZipError.new
+    end
+  end
+
+end

data/test/tc_managed_entries.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2013 The University of Manchester, UK.
+# Copyright (c) 2013, 2014 The University of Manchester, UK.
 #
 # All rights reserved.
 #
@@ -33,35 +33,41 @@
 require 'test/unit'
 require 'tmpdir'
 require 'zip-container'
+require 'helpers/entry_lists'
 
 # Classes to test managed entries.
-class ManagedZipContainer < ZipContainer::Container
+class ManagedZipContainer < ZipContainer::File
 
   private_class_method :new
 
   def initialize(filename)
     super(filename)
-    register_managed_entry(ZipContainer::ManagedDirectory.new("src", true))
-    register_managed_entry(ZipContainer::ManagedDirectory.new("test"))
+    test_file = ZipContainer::ManagedFile.new("test.txt")
+    deep_file = ZipContainer::ManagedFile.new("deep.txt")
+    deep_dir = ZipContainer::ManagedDirectory.new("deep",
+      :entries => [deep_file])
+    register_managed_entry(ZipContainer::ManagedDirectory.new("src", :required => true))
+    register_managed_entry(ZipContainer::ManagedDirectory.new("test",
+      :hidden => true, :entries => [deep_dir, test_file]))
     register_managed_entry(ZipContainer::ManagedDirectory.new("lib"))
-    register_managed_entry(ZipContainer::ManagedFile.new("index.html", true))
+    register_managed_entry(ZipContainer::ManagedFile.new("index.html", :required => true))
   end
 
 end
 
-class ExampleZipContainer < ZipContainer::Container
+class ExampleZipContainer < ZipContainer::File
 
   private_class_method :new
 
   def initialize(filename)
     super(filename)
-    register_managed_entry(ZipContainer::ManagedDirectory.new("dir", true))
-    register_managed_entry(ZipContainer::ManagedFile.new("greeting.txt", true))
+    register_managed_entry(ZipContainer::ManagedDirectory.new("dir", :required => true))
+    register_managed_entry(ZipContainer::ManagedFile.new("greeting.txt", :required => true))
   end
 
 end
 
-class ExampleZipContainer2 < ZipContainer::Container
+class ExampleZipContainer2 < ZipContainer::File
 
   private_class_method :new
 
@@ -70,7 +76,7 @@ class ExampleZipContainer2 < ZipContainer::Container
 
     valid = Proc.new { |contents| contents.match(/[Hh]ello/) }
     register_managed_entry(ZipContainer::ManagedFile.new("greeting.txt",
-      true, valid))
+      :required => true, :validation_proc => valid))
   end
 
   def ExampleZipContainer2.create(filename, &block)
@@ -117,7 +123,7 @@ class TestManagedEntries < Test::Unit::TestCase
       filename = File.join(dir, "test.container")
 
       assert_nothing_raised do
-        ZipContainer::Container.create(filename, $mimetype) do |c|
+        ZipContainer::File.create(filename, $mimetype) do |c|
           c.mkdir("META-INF")
           assert(c.file.exists?("META-INF"))
 
@@ -129,7 +135,7 @@ class TestManagedEntries < Test::Unit::TestCase
       end
 
       assert_nothing_raised(ZipContainer::MalformedContainerError) do
-        ZipContainer::Container.verify!(filename)
+        ZipContainer::File.verify!(filename)
       end
     end
   end
@@ -167,6 +173,26 @@ class TestManagedEntries < Test::Unit::TestCase
           c.file.open("index.html", "w") do |f|
             f.puts "<html />"
           end
+
+          # Test hidden entries before and after creation.
+          assert_nil(c.find_entry("test", :include_hidden => true))
+          assert_nil(c.find_entry("test/test.txt", :include_hidden => true))
+          c.dir.mkdir("test")
+          c.file.open("test/test.txt", "w") do |f|
+            f.puts "A test!"
+          end
+          assert_not_nil(c.find_entry("test", :include_hidden => true))
+          assert_not_nil(c.find_entry("test/test.txt", :include_hidden => true))
+
+          # Test deep hidden entries before and after creation.
+          assert_nil(c.find_entry("test/deep", :include_hidden => true))
+          assert_nil(c.find_entry("test/deep/deep.txt", :include_hidden => true))
+          c.dir.mkdir("test/deep")
+          c.file.open("test/deep/deep.txt", "w") do |f|
+            f.puts "A deep test!"
+          end
+          assert_not_nil(c.find_entry("test/deep", :include_hidden => true))
+          assert_not_nil(c.find_entry("test/deep/deep.txt", :include_hidden => true))
         end
       end
 
@@ -177,6 +203,95 @@ class TestManagedEntries < Test::Unit::TestCase
     end
   end
 
+  def test_hidden_entries
+    assert_nothing_raised do
+      ManagedZipContainer.open($subclass) do |c|
+        refute(c.hidden_entry?("src"))
+        refute(c.hidden_file?("src"))
+        refute(c.hidden_directory?("src"))
+
+        assert(c.hidden_entry?("test"))
+        assert(c.hidden_directory?("test"))
+        assert(c.hidden_entry?("test/"))
+        assert(c.hidden_directory?("test/"))
+        refute(c.hidden_file?("test"))
+
+        assert(c.hidden_entry?("test/deep"))
+        assert(c.hidden_directory?("test/deep"))
+        assert(c.hidden_entry?("test/deep/deep.txt"))
+        assert(c.hidden_file?("test/deep/deep.txt"))
+      end
+    end
+  end
+
+  def test_find_entry
+    assert_nothing_raised do
+      ManagedZipContainer.open($subclass) do |c|
+        assert_not_nil(c.find_entry("src"))
+        assert_not_nil(c.find_entry("src", :include_hidden => true))
+
+        assert_nil(c.find_entry("test"))
+        assert_nil(c.find_entry("test/test.txt"))
+        assert_not_nil(c.find_entry("test", :include_hidden => true))
+        assert_not_nil(c.find_entry("test/test.txt", :include_hidden => true))
+
+        assert_nil(c.find_entry("test/deep"))
+        assert_nil(c.find_entry("test/deep/deep.txt"))
+        assert_not_nil(c.find_entry("test/deep", :include_hidden => true))
+        assert_not_nil(c.find_entry("test/deep/deep.txt", :include_hidden => true))
+      end
+    end
+  end
+
+  def test_get_entry
+    ManagedZipContainer.open($subclass) do |c|
+      assert_nothing_raised(Errno::ENOENT) do
+        c.get_entry("src")
+      end
+      assert_nothing_raised(Errno::ENOENT) do
+        c.get_entry("src", :include_hidden => true)
+      end
+
+      assert_raise(Errno::ENOENT) do
+        c.get_entry("test")
+      end
+      assert_raise(Errno::ENOENT) do
+        c.get_entry("test/test.txt")
+      end
+      assert_nothing_raised(Errno::ENOENT) do
+        c.get_entry("test", :include_hidden => true)
+      end
+      assert_nothing_raised(Errno::ENOENT) do
+        c.get_entry("test/test.txt", :include_hidden => true)
+      end
+
+      assert_raise(Errno::ENOENT) do
+        c.get_entry("test/deep")
+      end
+      assert_raise(Errno::ENOENT) do
+        c.get_entry("test/deep/deep.txt")
+      end
+      assert_nothing_raised(Errno::ENOENT) do
+        c.get_entry("test/deep", :include_hidden => true)
+      end
+      assert_nothing_raised(Errno::ENOENT) do
+        c.get_entry("test/deep/deep.txt", :include_hidden => true)
+      end
+    end
+  end
+
+  def test_glob
+    ManagedZipContainer.open($subclass) do |c|
+      assert_equal(["index.html"], entry_list_names(c.glob("in*")))
+      assert_equal([], c.glob("test/**/*"))
+      assert_equal(["test/test.txt", "test/deep", "test/deep/deep.txt"],
+        entry_list_names(c.glob("test/**/*", :include_hidden => true)))
+      assert_equal(["test/test.txt", "test/deep/deep.txt"],
+        entry_list_names(c.glob("**/*.TXT", ::File::FNM_CASEFOLD,
+          :include_hidden => true)))
+    end
+  end
+
   def test_create_subclassed_mimetype
     Dir.mktmpdir do |dir|
       filename = File.join(dir, "test.container")