epo 0.0.1 → 0.0.2

data/README

@@ -43,14 +43,14 @@ $ tree db/
 db/
 └── user
     ├── peter
-    |   ├── resource-default.json  [1a]
+    |   ├── resource-epo-default.json  [1a]
     |   └── picture.png            [1b]
     ├── jon
-    |   ├── resource-default.json  [2a]
+    |   ├── resource-epo-default.json  [2a]
     |   ├── picture.png            [2b]
     |   └── pubkey.rsa.txt         [2c]
     └── marc
-        ├── resource-default.json  [3a]
+        ├── resource-epo-default.json  [3a]
         ├── picture.png            [3b]
         └── thumbnail.dat          [3c]
 
@@ -150,7 +150,22 @@ Iterates on all the DB items (as observations)
 
 welo >= 0.1.0
 derailleur >= 0.5.0
-a JSON library if you use json formatting
+a JSON library if you use json formatting (recommended)
+
+== Benchmark
+Config:
+* macbook pro (2010), without SSD:
+* ruby 1.9.2
+* json 1.5.1
+
+$ ruby example/benchmark.rb 
+  0.770000   1.020000   1.790000 (  4.563546)
+5935
+  1.160000   0.420000   1.580000 (  1.601897)
+
+So, roughly 5 seconds to write 6000 records, and 2 seconds to read them back.
+No sync operation nor cache flush was forced in between the results. That's maybe why
+we can read back only 5935 records out of 6000.
 
 == License
 

data/Rakefile

@@ -31,7 +31,7 @@ spec = Gem::Specification.new do |s|
         s.executables = []
         s.has_rdoc = true
 
-        s.add_dependency('derailleur', '>= 0.0.5')
+        s.add_dependency('derailleur', '>= 0.0.6')
         s.add_dependency('welo', '>= 0.1.0')
 end
 

data/TODO

@@ -1,9 +1,2 @@
-* delete record/observation
-* maybe with some modifications to Derailleur:
-  - graceful not found case
-  - clever pruning when finding:
-    - when path is a directory and there is no node, prune
-    - when path is a directory but there is a node, continue
-  - cache observation structs somewhere in the db or in the observer
-* fiber-friendly batch operations
+* nesting/epitheting resources
 * register on inotify events

data/lib/epo/core/db.rb

@@ -39,7 +39,7 @@ module EPO
     # Registers a model on a derailleur node at its path_model
     # Does not modify self.models
     def build_route_for_model(model)
-      path = model.path_model(identifying_sym) #XXX allow to change the db identifying name
+      path = File.join(model.path_model(identifying_sym), ':filename')
       node = build_route(path)
       node.content = model
     end
@@ -75,20 +75,79 @@ module EPO
       extensions.find{|ext| ext == File.extname(path)}
     end
 
+    # Returns the main name of a path, i.e., the basename without
+    # the extension 
+    # * main_name('/a/b/c/foo.bar') #=> 'foo'
+    def main_name(path)
+      File.basename(path).sub(/\.[^\.]+$/,'')
+    end
+
+    def understands_filename?(path)
+      understands_ext?(path) and
+      understands_main_name?(path)
+    end
+
+    def understands_main_name?(path)
+      main_name(path) =~ resource_regexp
+    end
+
+    RESOURCE_REGEXP = %r{resource-epo-\w+}
+
+    def resource_regexp
+      RESOURCE_REGEXP
+    end
+
     # Returns the perspective name and extension name (a 2 items array)
     # for the given path.
     # By default the blobs for resources content are stored in files named
     # 'resource-<persp><ext>' with ext starting with a dot
     def persp_and_ext_for_basename(path)
-      base = File.basename(path).sub('resource-','').sub(/\.[^\.]+$/,'')
-      [base, File.extname(path)]
+      [main_name(path).sub('resource-epo-',''), File.extname(path)]
     end
 
     # Returns the basename of a resource blob for a perspective named persp and
     # in a format with extension ext (including the leading dot).  
     # see also persp_and_ext_for_basename
     def basename_for_persp_and_ext(persp, ext)
-      "resource-#{persp}#{ext}"
+      "resource-epo-#{persp}#{ext}"
+    end
+
+    # Deletes a resource by removing its identifying directory.  Beware because
+    # this method doesn't care about other files which may coexist in the same
+    # filesystem branch.
+    def delete_completely(root, resource)
+      path = File.join(root, resource.path(identifying_sym))
+      FileUtils.rm_rf(path)
+
+      # removes the empty directories upward
+      (resource.identifiers(identifying_sym).size - 1).times do |t|
+        path = File.split(path).first
+        begin
+          FileUtils.rmdir(path)
+        rescue Errno::ENOTEMPTY
+          break
+        end
+      end
+    end
+
+    def delete(root, resource)
+      remaining_path = File.join(root, resource.path(identifying_sym))
+      # removes the resource-epo-* files
+      Dir.entries(remaining_path).each do |e|
+        if e.start_with?('resource-epo-')
+          FileUtils.rm(File.join(remaining_path, e)) 
+        end
+      end
+
+      # removes the empty directories upward
+      resource.identifiers(identifying_sym).size.times do |t|
+        begin
+          Dir.rmdir(remaining_path)
+          remaining_path = File.split(remaining_path).first
+        rescue Errno::ENOTEMPTY
+          break
+        end
+      end
     end
 
     # Saves one or more resource at the filesystem path given at root
@@ -171,7 +230,7 @@ module EPO
     # Iterates on every resource found and understood in the filesystem
     # directory root.
     # If no block is given, returns an iterator.
-    def each_resource(root) 
+    def each_resource_observation(root) 
       if block_given?
         xp = observer
         models.each do |model|
@@ -181,7 +240,7 @@ module EPO
         end
         xp.read_tree(root)
       else
-        Enumerator.new(self, :each_resource, root)
+        Enumerator.new(self, :each_resource_observation, root)
       end
     end
 

data/lib/epo/core/observer.rb

@@ -21,6 +21,9 @@ module EPO
     # The DB able to tell if a path is understandable or not
     attr_accessor :db
 
+    # A cache for the observation structures
+    attr_accessor :structures
+
     # Creates and return a new observer from a DB. 
     # It will take the models from the DB.
     def self.for_db(db)
@@ -34,35 +37,26 @@ module EPO
     def initialize(models=[])
       super(models)
       @db = DB.new(models)
+      @structures = {}
       register(:observation) do |o|
         dispatch(o)
       end
     end
 
-    # Read a single path, the root is the part of the path corresponding
-    # to where on the filesystem the database is rooted.
-    # e.g.  for a path in a photo collection:
-    #       /home/crapooze/project/foobar/db/photo/1
-    #       the root is likely to be:
-    #       /home/crapooze/project/foobar/db
-    # If a successful observation happens, then it will call the relevant hooks.
-    def read_path(path, root=nil)
-      full_dirname, base = File.split(path)
-      dirname = if root
-                  full_dirname.sub(root,'')
-                else
-                  full_dirname
-                end
-      #XXX may raise an exception for unknown path, we should rescue this/use a
-      #silent method and test for nil
-      node = db.get_route(dirname)
+    def get_node_for_path(path, root=nil)
+      path = path.sub(root,'') if root
+      db.get_route_silent(path)
+    end
 
+    def read_path_as_resource(path, model)
       persp_str = db.persp_and_ext_for_basename(path).first
-      persp = node.content.perspectives.keys.find{|k| k.to_s == persp_str}
-      #XXX no need to create this many time, should cache it
-      st = Welo::ObservationStruct.new_for_resource_in_perspective(node.content, persp)
-      source = Source.new(db, path)
-      observe_source(source, st)
+      persp = model.perspectives.keys.find{|k| k.to_s == persp_str}
+      observe_source(Source.new(db, path), structure(model, persp))
+    end
+
+    def structure(model, persp)
+      pair = [model, persp]
+      @structures[pair] ||= Welo::ObservationStruct.new_for_resource_in_perspective(model, persp)
     end
 
     # Recursively reads the files in the filesystem (with Find).
@@ -70,10 +64,15 @@ module EPO
     # Currently, there is no pruning, or control possible.
     def read_tree(root)
       Find.find(root) do |path|
-        if File.directory?(path)
-          #XXX maybe prune the branch if valid but has no content
-        elsif db.understands_ext?(path)
-          read_path(path, root) 
+        node = get_node_for_path(path, root) 
+        if node 
+          if node.content #a model attached to a file in a directory
+            if db.understands_filename?(path)
+              read_path_as_resource(path, node.content)
+            end
+          end
+        else #the db doesn't understand this branch, we'd rather drop now
+          Find.prune
         end
       end
     end

data/lib/epo.rb

@@ -1,6 +1,6 @@
 
 module EPO
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
   AUTHORS = ["crapooze"]
   WEBSITE = "https://github.com/crapooze/epo"
   LICENCE = "MIT"

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - crapooze
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-19 00:00:00 -04:00
+date: 2011-03-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,8 +28,8 @@ dependencies:
         segments: 
         - 0
         - 0
-        - 5
-        version: 0.0.5
+        - 6
+        version: 0.0.6
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency