async-caldav 1.2.4 → 1.3.0

data/lib/async/caldav/storage/filesystem.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "scampi"
-require "async/caldav"
 require 'json'
 require 'fileutils'
 
@@ -15,7 +12,11 @@ module Async
           @sync_snapshots = {}
           FileUtils.mkdir_p(@root)
           @root_normalized = ::File.expand_path(@root)
-          @root_with_separator = @root_normalized.end_with?(::File::SEPARATOR) ? @root_normalized : "#{@root_normalized}#{::File::SEPARATOR}"
+          if @root_normalized.end_with?(::File::SEPARATOR)
+            @root_with_separator = @root_normalized
+          else
+            @root_with_separator = "#{@root_normalized}#{::File::SEPARATOR}"
+          end
         end
 
         # --- Collections ---
@@ -24,11 +25,11 @@ module Async
           dir = full_path(path)
           FileUtils.mkdir_p(dir)
           meta = {
-            "type" => (props[:type] || :collection).to_s,
+            "type"        => (props[:type] || :collection).to_s,
             "displayname" => props[:displayname],
             "description" => props[:description],
-            "color" => props[:color],
-            "props" => props[:props] || {}
+            "color"       => props[:color],
+            "props"       => props[:props] || {},
           }
           File.write(File.join(dir, ".collection.json"), JSON.pretty_generate(meta))
           symbolize(meta)
@@ -36,8 +37,11 @@ module Async
 
         def get_collection(path)
           meta_file = File.join(full_path(path), ".collection.json")
-          return nil unless File.exist?(meta_file)
-          symbolize(JSON.parse(File.read(meta_file)))
+          if File.exist?(meta_file)
+            symbolize(JSON.parse(File.read(meta_file)))
+          else
+            nil
+          end
         end
 
         def delete_collection(path)
@@ -52,36 +56,49 @@ module Async
 
         def list_collections(parent_path)
           dir = full_path(parent_path)
-          return [] unless File.directory?(dir)
-
-          Dir.children(dir).filter_map do |name|
-            child_dir = File.join(dir, name)
-            meta_file = File.join(child_dir, ".collection.json")
-            next unless File.directory?(child_dir) && File.exist?(meta_file)
-
-            child_path = File.join(parent_path, name).sub(%r{/*$}, "/")
-            [child_path, symbolize(JSON.parse(File.read(meta_file)))]
+          if File.directory?(dir)
+            Dir.children(dir).filter_map do |name|
+              child_dir = File.join(dir, name)
+              meta_file = File.join(child_dir, ".collection.json")
+              unless File.directory?(child_dir) && File.exist?(meta_file)
+                next
+              end
+
+              child_path = File.join(parent_path, name).sub(%r{/*$}, "/")
+              [child_path, symbolize(JSON.parse(File.read(meta_file)))]
+            end
+          else
+            []
           end
         end
 
         def update_collection(path, props)
           col = get_collection(path)
-          return nil unless col
-
-          col[:displayname] = props[:displayname] if props.key?(:displayname)
-          col[:description] = props[:description] if props.key?(:description)
-          col[:color] = props[:color] if props.key?(:color)
-          col[:props] = (col[:props] || {}).merge(props[:props]) if props.key?(:props)
-
-          meta = {
-            "type" => col[:type].to_s,
-            "displayname" => col[:displayname],
-            "description" => col[:description],
-            "color" => col[:color],
-            "props" => col[:props] || {}
-          }
-          File.write(File.join(full_path(path), ".collection.json"), JSON.pretty_generate(meta))
-          col
+          if col
+            if props.key?(:displayname)
+              col[:displayname] = props[:displayname]
+            end
+            if props.key?(:description)
+              col[:description] = props[:description]
+            end
+            if props.key?(:color)
+              col[:color] = props[:color]
+            end
+            if props.key?(:props)
+              col[:props] = (col[:props] || {}).merge(props[:props])
+            end
+            meta = {
+              "type"        => col[:type].to_s,
+              "displayname" => col[:displayname],
+              "description" => col[:description],
+              "color"       => col[:color],
+              "props"       => col[:props] || {},
+            }
+            File.write(File.join(full_path(path), ".collection.json"), JSON.pretty_generate(meta))
+            col
+          else
+            nil
+          end
         end
 
         def collection_exists?(path)
@@ -124,18 +141,24 @@ module Async
 
         def list_items(collection_path)
           dir = full_path(collection_path)
-          return [] unless File.directory?(dir)
-
-          Dir.children(dir).filter_map do |name|
-            next if name.start_with?(".")
-            file = File.join(dir, name)
-            next unless File.file?(file)
-
-            item_path = File.join(collection_path, name)
-            body = File.read(file)
-            content_type = guess_content_type(name)
-            etag = Protocol::Caldav::ETag.compute(body)
-            [item_path, { body: body, content_type: content_type, etag: etag }]
+          if File.directory?(dir)
+            Dir.children(dir).filter_map do |name|
+              if name.start_with?(".")
+                next
+              end
+              file = File.join(dir, name)
+              unless File.file?(file)
+                next
+              end
+
+              item_path = File.join(collection_path, name)
+              body = File.read(file)
+              content_type = guess_content_type(name)
+              etag = Protocol::Caldav::ETag.compute(body)
+              [item_path, { body: body, content_type: content_type, etag: etag }]
+            end
+          else
+            []
           end
         end
 
@@ -180,11 +203,11 @@ module Async
           col = get_collection(collection_path) || {}
           item_etags = items.map { |_, data| data[:etag] }
           ctag = Protocol::Caldav::CTag.compute(
-            path: collection_path,
+            path:        collection_path,
             displayname: col[:displayname],
             description: col[:description],
-            color: col[:color],
-            item_etags: item_etags
+            color:       col[:color],
+            item_etags:  item_etags,
           )
           token = "http://caldav.local/sync/#{ctag}"
           @sync_snapshots[token] = { collection_path => snapshot }
@@ -193,69 +216,71 @@ module Async
 
         def sync_changes(collection_path, token)
           old_snapshot_entry = @sync_snapshots[token]
-          return nil unless old_snapshot_entry
-
-          old_snapshot = old_snapshot_entry[collection_path] || {}
-          new_token = snapshot_sync(collection_path)
-          current_items = list_items(collection_path)
-          current = {}
-          current_items.each { |path, data| current[path] = data[:etag] }
-
-          changes = []
-          current.each do |path, etag|
-            if !old_snapshot.key?(path) || old_snapshot[path] != etag
-              changes << [path, :modified]
+          if old_snapshot_entry
+            old_snapshot = old_snapshot_entry[collection_path] || {}
+            new_token = snapshot_sync(collection_path)
+            current_items = list_items(collection_path)
+            current = {}
+            current_items.each { |path, data| current[path] = data[:etag] }
+            changes = []
+            current.each do |path, etag|
+              if !old_snapshot.key?(path) || old_snapshot[path] != etag
+                changes << [path, :modified]
+              end
             end
+            old_snapshot.each_key do |path|
+              unless current.key?(path)
+                changes << [path, :deleted]
+              end
+            end
+            [new_token, changes]
+          else
+            nil
           end
-          old_snapshot.each_key do |path|
-            changes << [path, :deleted] unless current.key?(path)
-          end
-
-          [new_token, changes]
         end
 
         private
 
-        def full_path(path)
-          if valid_path?(path)
-            expanded = ::File.expand_path(::File.join(@root, path))
-            if expanded == @root_normalized || expanded.start_with?(@root_with_separator)
-              expanded
+          def full_path(path)
+            if valid_path?(path)
+              expanded = ::File.expand_path(::File.join(@root, path))
+              if expanded == @root_normalized || expanded.start_with?(@root_with_separator)
+                expanded
+              else
+                raise ArgumentError, "path escapes root: #{path.inspect}"
+              end
             else
-              raise ArgumentError, "path escapes root: #{path.inspect}"
+              raise ArgumentError, "invalid path: #{path.inspect}"
             end
-          else
-            raise ArgumentError, "invalid path: #{path.inspect}"
           end
-        end
 
-        def valid_path?(path)
-          path.is_a?(String) && path.valid_encoding? && !path.include?("\0")
-        end
+          def valid_path?(path)
+            path.is_a?(String) && path.valid_encoding? && !path.include?("\0")
+          end
 
-        def stat(path)
-          ::File.stat(full_path(path))
-        rescue Errno::ENOENT, Errno::ELOOP
-          nil
-        end
+          def stat(path)
+            ::File.stat(full_path(path))
+          rescue Errno::ENOENT, Errno::ELOOP
+            nil
+          end
 
-        def guess_content_type(path)
-          case File.extname(path).downcase
-          when ".ics" then "text/calendar"
-          when ".vcf" then "text/vcard"
-          else "application/octet-stream"
+          def guess_content_type(path)
+            case File.extname(path).downcase
+            when ".ics" then "text/calendar"
+            when ".vcf" then "text/vcard"
+            else "application/octet-stream"
+            end
           end
-        end
 
-        def symbolize(hash)
-          {
-            type: hash["type"]&.to_sym || :collection,
-            displayname: hash["displayname"],
-            description: hash["description"],
-            color: hash["color"],
-            props: hash["props"] || {}
-          }
-        end
+          def symbolize(hash)
+            {
+              type:        hash["type"]&.to_sym || :collection,
+              displayname: hash["displayname"],
+              description: hash["description"],
+              color:       hash["color"],
+              props:       hash["props"] || {},
+            }
+          end
       end
     end
   end
@@ -263,156 +288,158 @@ end
 
 require 'tmpdir'
 
-test do
-  describe "Async::Caldav::Storage::Filesystem" do
-    it "creates and retrieves a collection" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.create_collection("/cal/", type: :calendar, displayname: "Cal")
-        col = s.get_collection("/cal/")
-        col[:displayname].should.equal "Cal"
-        col[:type].should.equal :calendar
-      end
+__END__
+
+require_relative "../../caldav"
+
+describe "Async::Caldav::Storage::Filesystem" do
+  it "creates and retrieves a collection" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.create_collection("/cal/", type: :calendar, displayname: "Cal")
+      col = s.get_collection("/cal/")
+      col[:displayname].should.equal "Cal"
+      col[:type].should.equal :calendar
     end
+  end
 
-    it "deletes collection and its items" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.create_collection("/cal/")
-        s.put_item("/cal/ev.ics", "data", "text/calendar")
-        s.delete_collection("/cal/")
-        s.get_collection("/cal/").should.be.nil
-        s.get_item("/cal/ev.ics").should.be.nil
-      end
+  it "deletes collection and its items" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.create_collection("/cal/")
+      s.put_item("/cal/ev.ics", "data", "text/calendar")
+      s.delete_collection("/cal/")
+      s.get_collection("/cal/").should.be.nil
+      s.get_item("/cal/ev.ics").should.be.nil
     end
+  end
 
-    it "lists direct child collections" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.create_collection("/admin/a/")
-        s.create_collection("/admin/b/")
-        s.list_collections("/admin/").length.should.equal 2
-      end
+  it "lists direct child collections" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.create_collection("/admin/a/")
+      s.create_collection("/admin/b/")
+      s.list_collections("/admin/").length.should.equal 2
     end
+  end
 
-    it "updates collection properties" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.create_collection("/cal/", displayname: "Old")
-        s.update_collection("/cal/", displayname: "New")
-        s.get_collection("/cal/")[:displayname].should.equal "New"
-      end
+  it "updates collection properties" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.create_collection("/cal/", displayname: "Old")
+      s.update_collection("/cal/", displayname: "New")
+      s.get_collection("/cal/")[:displayname].should.equal "New"
     end
+  end
 
-    it "puts and retrieves an item with etag" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        item, is_new = s.put_item("/cal/ev.ics", "BEGIN:VCALENDAR", "text/calendar")
-        is_new.should.equal true
-        item[:etag].should.not.be.nil
-        s.get_item("/cal/ev.ics")[:body].should.equal "BEGIN:VCALENDAR"
-      end
+  it "puts and retrieves an item with etag" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      item, is_new = s.put_item("/cal/ev.ics", "BEGIN:VCALENDAR", "text/calendar")
+      is_new.should.equal true
+      item[:etag].should.not.be.nil
+      s.get_item("/cal/ev.ics")[:body].should.equal "BEGIN:VCALENDAR"
     end
+  end
 
-    it "persists across instances" do
-      Dir.mktmpdir do |dir|
-        s1 = Async::Caldav::Storage::Filesystem.new(dir)
-        s1.create_collection("/cal/", type: :calendar, displayname: "Persist")
-        s1.put_item("/cal/ev.ics", "body", "text/calendar")
+  it "persists across instances" do
+    Dir.mktmpdir do |dir|
+      s1 = Async::Caldav::Storage::Filesystem.new(dir)
+      s1.create_collection("/cal/", type: :calendar, displayname: "Persist")
+      s1.put_item("/cal/ev.ics", "body", "text/calendar")
 
-        s2 = Async::Caldav::Storage::Filesystem.new(dir)
-        s2.get_collection("/cal/")[:displayname].should.equal "Persist"
-        s2.get_item("/cal/ev.ics")[:body].should.equal "body"
-      end
+      s2 = Async::Caldav::Storage::Filesystem.new(dir)
+      s2.get_collection("/cal/")[:displayname].should.equal "Persist"
+      s2.get_item("/cal/ev.ics")[:body].should.equal "body"
     end
+  end
 
-    it "list_items excludes hidden files" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.create_collection("/cal/")
-        s.put_item("/cal/ev.ics", "EVENT", "text/calendar")
-        items = s.list_items("/cal/")
-        items.map(&:first).any? { |p| p.include?(".collection.json") }.should.equal false
-        items.map(&:first).any? { |p| p.include?("ev.ics") }.should.equal true
-      end
+  it "list_items excludes hidden files" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.create_collection("/cal/")
+      s.put_item("/cal/ev.ics", "EVENT", "text/calendar")
+      items = s.list_items("/cal/")
+      items.map(&:first).any? { |p| p.include?(".collection.json") }.should.equal false
+      items.map(&:first).any? { |p| p.include?("ev.ics") }.should.equal true
     end
+  end
 
-    it "deletes an item" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.put_item("/cal/ev.ics", "data", "text/calendar")
-        s.delete_item("/cal/ev.ics").should.equal true
-        s.get_item("/cal/ev.ics").should.be.nil
-        s.delete_item("/cal/ev.ics").should.equal false
-      end
+  it "deletes an item" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.put_item("/cal/ev.ics", "data", "text/calendar")
+      s.delete_item("/cal/ev.ics").should.equal true
+      s.get_item("/cal/ev.ics").should.be.nil
+      s.delete_item("/cal/ev.ics").should.equal false
     end
+  end
 
-    it "moves an item" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.put_item("/cal/a.ics", "data", "text/calendar")
-        s.move_item("/cal/a.ics", "/cal/b.ics")
-        s.get_item("/cal/a.ics").should.be.nil
-        s.get_item("/cal/b.ics")[:body].should.equal "data"
-      end
+  it "moves an item" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.put_item("/cal/a.ics", "data", "text/calendar")
+      s.move_item("/cal/a.ics", "/cal/b.ics")
+      s.get_item("/cal/a.ics").should.be.nil
+      s.get_item("/cal/b.ics")[:body].should.equal "data"
     end
+  end
 
-    it "reports existence correctly" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.exists?("/nope").should.equal false
-        s.create_collection("/col/")
-        s.exists?("/col/").should.equal true
-        s.put_item("/col/x.ics", "d", "text/calendar")
-        s.exists?("/col/x.ics").should.equal true
-      end
+  it "reports existence correctly" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.exists?("/nope").should.equal false
+      s.create_collection("/col/")
+      s.exists?("/col/").should.equal true
+      s.put_item("/col/x.ics", "d", "text/calendar")
+      s.exists?("/col/x.ics").should.equal true
     end
+  end
 
-    it "get_multi returns items and nils" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.put_item("/cal/a.ics", "A", "text/calendar")
-        result = s.get_multi(["/cal/a.ics", "/cal/nope.ics"])
-        result.length.should.equal 2
-        result[0][1][:body].should.equal "A"
-        result[1][1].should.be.nil
-      end
+  it "get_multi returns items and nils" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.put_item("/cal/a.ics", "A", "text/calendar")
+      result = s.get_multi(["/cal/a.ics", "/cal/nope.ics"])
+      result.length.should.equal 2
+      result[0][1][:body].should.equal "A"
+      result[1][1].should.be.nil
     end
+  end
 
-    it "guesses content types from extension" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        s.put_item("/cal/ev.ics", "cal", "text/calendar")
-        s.put_item("/addr/c.vcf", "card", "text/vcard")
-        s.get_item("/cal/ev.ics")[:content_type].should.equal "text/calendar"
-        s.get_item("/addr/c.vcf")[:content_type].should.equal "text/vcard"
-      end
+  it "guesses content types from extension" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      s.put_item("/cal/ev.ics", "cal", "text/calendar")
+      s.put_item("/addr/c.vcf", "card", "text/vcard")
+      s.get_item("/cal/ev.ics")[:content_type].should.equal "text/calendar"
+      s.get_item("/addr/c.vcf")[:content_type].should.equal "text/vcard"
     end
+  end
 
-    it "rejects path traversal attempts" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        lambda { s.get_item("/../../etc/passwd") }.should.raise ArgumentError
-        lambda { s.put_item("/cal/../../escape.ics", "x", "text/calendar") }.should.raise ArgumentError
-      end
+  it "rejects path traversal attempts" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      lambda { s.get_item("/../../etc/passwd") }.should.raise ArgumentError
+      lambda { s.put_item("/cal/../../escape.ics", "x", "text/calendar") }.should.raise ArgumentError
     end
+  end
 
-    it "rejects NUL byte in path" do
-      Dir.mktmpdir do |dir|
-        s = Async::Caldav::Storage::Filesystem.new(dir)
-        lambda { s.get_item("/cal\0/x.ics") }.should.raise ArgumentError
-      end
+  it "rejects NUL byte in path" do
+    Dir.mktmpdir do |dir|
+      s = Async::Caldav::Storage::Filesystem.new(dir)
+      lambda { s.get_item("/cal\0/x.ics") }.should.raise ArgumentError
     end
+  end
 
-    it "same body produces same etag across backends" do
-      body = "BEGIN:VCALENDAR\r\nEND:VCALENDAR"
-      mock = Async::Caldav::Storage::Mock.new
-      mock.put_item("/a.ics", body, "text/calendar")
-      Dir.mktmpdir do |dir|
-        fs = Async::Caldav::Storage::Filesystem.new(dir)
-        fs.put_item("/a.ics", body, "text/calendar")
-        mock.etag("/a.ics").should.equal fs.etag("/a.ics")
-      end
+  it "same body produces same etag across backends" do
+    body = "BEGIN:VCALENDAR\r\nEND:VCALENDAR"
+    mock = Async::Caldav::Storage::Mock.new
+    mock.put_item("/a.ics", body, "text/calendar")
+    Dir.mktmpdir do |dir|
+      fs = Async::Caldav::Storage::Filesystem.new(dir)
+      fs.put_item("/a.ics", body, "text/calendar")
+      mock.etag("/a.ics").should.equal fs.etag("/a.ics")
     end
   end
-end
+end