zena 1.0.0.rc2 → 1.0.0.rc3

data/lib/zena/use/query_builder.rb

@@ -5,14 +5,20 @@ module Zena
       module ViewMethods
         include RubyLess
         safe_method [:query_parse, String] => {:class => String, :accept_nil => true}
+        safe_method :query_errors => {:class => String, :nil => true}
 
         def find_node_by_zip(zip)
           return nil unless zip
           secure(Node) { Node.find_by_zip(zip) }
         end
 
+        def query_errors
+          @query_errors
+        end
+
         def query(class_name, node_name, pseudo_sql, opts = {})
           type = opts[:type] || :find
+          @query_errors = nil
           if klass = VirtualClass[class_name]
             begin
               query = klass.build_query(:all, pseudo_sql,
@@ -28,7 +34,7 @@ module Zena
                 return klass.do_find(:all, eval(query.to_s))
               end
             rescue ::QueryBuilder::Error => err
-              # FIXME: how to return error messages to the user ?
+              @query_errors = "<span class='query'>#{pseudo_sql}</span> <span class='error'>#{err}</span>"
             end
           end
           # error
@@ -71,6 +77,7 @@ module Zena
             end
 
             if arg =~ DATE_FIELD_REGEXP
+              # FIXME: Use to_utc and date function in Zena::Db
               arg = query_parse_dates(arg)
               first = arg.first
             end
@@ -202,7 +209,7 @@ module Zena
 
         # Resolve unknown methods by trying to build a pseudo-sql query with QueryBuilder.
         def querybuilder_eval(method = @method)
-          return nil if node.klass.kind_of?(Array) # list context
+          node = single_node
 
           if method =~ /^\d+$/
             finder = {:method => "find_node_by_zip(#{method})", :class => Node, :nil => true}
@@ -234,34 +241,54 @@ module Zena
         def node_context_vars(finder)
           sub_context = super
           query = finder[:query]
-          if query && (pagination_key = query.pagination_key)
-            set_context_var('paginate', 'key', pagination_key, sub_context)
-
+          if query && ((pagination_key = query.pagination_key) || child['count'])
             node_count = get_var_name('paginate', 'nodes', sub_context)
-            page_count = get_var_name('paginate', 'count', sub_context)
-            curr_page  = get_var_name('paginate', 'current', sub_context)
-
-            # Give access to the page number through the pagination key.
-            set_context_var('set_var', pagination_key, RubyLess::TypedString.new(curr_page, Number))
-            # Give access to page_count and count
-            # FIXME: DOC
-            set_context_var('set_var', 'page_count', RubyLess::TypedString.new(page_count, Number))
             set_context_var('set_var', 'count', RubyLess::TypedString.new(node_count, Number))
 
-            out "<% #{node_count} = Node.do_find(:count, #{query.to_s(:count)}); #{page_count} = (#{node_count} / #{query.page_size.to_f}).ceil; #{curr_page} = [1,params[:#{pagination_key}].to_i].max %>"
+            res = "#{node_count} = Node.do_find(:count, #{query.to_s(:count)})"
+            if pagination_key
+              # Full pagination needed
+              set_context_var('paginate', 'key', pagination_key, sub_context)
+
+              page_count = get_var_name('paginate', 'count', sub_context)
+              curr_page  = get_var_name('paginate', 'current', sub_context)
+
+              # Give access to the page number through the pagination key.
+              set_context_var('set_var', pagination_key, RubyLess::TypedString.new(curr_page, Number))
+              # Give access to page_count and count
+              # FIXME: DOC
+              set_context_var('set_var', 'page_count', RubyLess::TypedString.new(page_count, Number))
+
+              res << "; #{page_count} = (#{node_count} / #{query.page_size.to_f}).ceil; #{curr_page} = [1,params[:#{pagination_key}].to_i].max"
+            end
+
+            out "<% #{res} %>"
+
           elsif finder[:method].kind_of?(RubyLess::TypedString)
             # Hash passed with :zafu => {} is inserted into context
             sub_context.merge!(finder[:method].opts[:zafu] || {})
           end
 
-          sub_context[:has_link_id] = query && query.select.to_s =~ / AS link_id/
+          sub_context[:has_link_id] = query && query.select_keys.include?('link_id')
 
           sub_context
         end
 
         private
+          def single_node
+            node = self.node
+            while node.list_context?
+              node = node.up
+              if !node
+                raise ::QueryBuilder::Error.new("Could not access node context  query builder from list #{self.node.class_name}")
+              end
+            end
+            node
+          end
+
           # Build a Query object from SQLiss.
           def build_query(count, pseudo_sql, raw_filters = [])
+            node = single_node
 
             if !node.klass.respond_to?(:build_query)
               raise ::QueryBuilder::Error.new("No query builder for class #{node.klass}")
@@ -299,8 +326,12 @@ module Zena
 
             finder = get_finder(query, count)
 
-            if count != :count && else_clause = @params[:else]
-              else_clause = RubyLess.translate(self, else_clause)
+            if count != :count && params[:else]
+              begin
+                else_clause = RubyLess.translate(self, params[:else])
+              rescue RubyLess::Error
+                else_clause = RubyLess.translate(self, "find(#{params[:else].inspect})")
+              end
 
               if else_clause.klass == Array
                 else_klass = else_clause.opts[:elem]
@@ -367,6 +398,7 @@ module Zena
           def get_pseudo_sql(rel, params)
             parts   = [rel.dup]
             filters = []
+            group_order_limit = ''
 
             if params[:from]
               parts << params[:from]
@@ -389,21 +421,21 @@ module Zena
             # [group by GROUP_CLAUSE] [order by ORDER_CLAUSE] [limit num(,num)] [offset num] [paginate key]
 
             if group = params[:group]
-              parts[-1] << " group by #{group}" unless parts[0] =~ /group by/
+              group_order_limit << " group by #{group}" unless parts[0] =~ /group by/
             end
 
             if order = params[:order]
-              parts[-1] << " order by #{order}" unless parts[0] =~ /order by/
+              group_order_limit << " order by #{order}" unless parts[0] =~ /order by/
             end
 
             if paginate = params[:paginate]
               page_size = params[:limit].to_i
               page_size = 20 if page_size < 1
-              parts[-1] << " limit #{page_size} paginate #{paginate.gsub(/[^a-z_A-Z]/,'')}"
+              group_order_limit << " limit #{page_size} paginate #{paginate.gsub(/[^a-z_A-Z]/,'')}"
             else
               [:limit, :offset].each do |k|
                 next unless params[k]
-                parts[-1] << " #{k} #{params[k]}" unless parts[0] =~ / #{k} /
+                group_order_limit << " #{k} #{params[k]}" unless parts[0] =~ / #{k} /
               end
             end
 
@@ -421,9 +453,9 @@ module Zena
             end
 
             if finders.size > 1
-              finders = "(#{finders.join(') or (')})"
+              finders = "(#{finders.join(') or (')})#{group_order_limit}"
             else
-              finders = finders.first
+              finders = finders.first + group_order_limit
             end
 
             return [finders, parse_raw_filters(params)]

data/lib/zena/use/query_node.rb

@@ -29,19 +29,18 @@ module Zena
 
         # Find related nodes.
         # See Node#build_find for details on the options available.
-        # TODO: do we need rubyless translate here ?
-        def find(count, rel, opts = {})
-          if !opts[:skip_rubyless] && rel.size == 1 && type = RubyLess::SafeClass.safe_method_type_for(self.class, [rel.first])
+        # TODO: do we need rubyless translate here ? It should be removed.
+        def find(count, pseudo_sql, opts = {})
+          if !opts[:skip_rubyless] && type = RubyLess::SafeClass.safe_method_type_for(self.class, [pseudo_sql])
             self.send(type[:method])
           else
             begin
-              query = self.class.build_query(count, rel,
+              query = self.class.build_query(count, pseudo_sql,
                 :node_name       => 'self',
                 :main_class      => virtual_class,
                 :rubyless_helper => (opts[:rubyless_helper] || virtual_class), # should it be || self ?
                 :default         => opts[:default]
               )
-
               if limit = opts[:limit]
                 query.limit  = " LIMIT #{limit.to_i}"
                 query.offset = " OFFSET #{opts[:offset].to_i}"
@@ -52,7 +51,7 @@ module Zena
 
             type = [:all, :first].include?(count) ? :find : :count
 
-            self.class.do_find(count, eval(query.to_s(type)))
+            Node.do_find(count, eval(query.to_s(type)))
           end
         end
 
@@ -105,7 +104,7 @@ module Zena
         after_process :insert_links_fields
         after_process :secure_query
 
-        load_custom_queries Bricks.paths_for('queries')
+        load_custom_queries Bricks.paths_for('zena/queries')
 
         CORE_CONTEXTS = %w{parent project section}
 
@@ -187,7 +186,7 @@ module Zena
           end
         end
 
-        # Overwrite this and take car to check for valid fields.
+        # Overwrite this and take care to check for valid fields.
         def process_field(field_name)
           if fld = @query.attributes_alias[field_name]
             # use custom query alias value defined in select clause: 'custom_a AS validation'
@@ -238,6 +237,11 @@ module Zena
             end
 
             # property or real column
+
+            # FIXME !!!! Why does this happen ?
+            return nil if @query.main_class.columns.kind_of?(Array)
+
+
             column = @query.main_class.columns[field_name]
             if column && column.indexed?
               if column.index == true
@@ -291,6 +295,15 @@ module Zena
               add_table('nodes_roles')
               "(#{table('nodes_roles')}.node_id = #{table('nodes')}.id AND #{table('nodes_roles')}.role_id = #{role.id})"
             end
+          elsif left.first == :function && left.last.last == 'date'
+            # transform "foo.date = baz"
+            # [:function, [:field, "foo"], [:method, "date"]]
+            # [:field, baz]
+            # ==> into
+            # "baz >= foo and foo < baz + 1 day"
+            a = left[1]
+            b = right
+            process([:and, [:<=, b, a], [:<, a, [:+, b, [:interval, [:integer, '1'], 'day']]]])
           else
             super
           end
@@ -320,17 +333,10 @@ module Zena
           elsif arg1[0] == :field && arg2[0] == :method
             # contact.log_at  or  log_at.year
             # arg1 = [:field, "contact"]
+            class_name = arg1[1]
             # arg2 = [:method, "name"]
-            class_or_field    = arg1[1]
-            field_or_function = arg2[1]
-            if @query.main_class.columns[class_or_field]
-              # log_at.year
-              return [arg1, arg2]
-            else
-              class_name = class_or_field
-              field_name = field_or_function
-              function   = nil
-            end
+            field_name = arg2[1]
+            function   = nil
           else
             return [arg1, arg2]
           end
@@ -358,7 +364,7 @@ module Zena
         # ******** And maybe overwrite these **********
         def parse_custom_query_argument(key, value)
           return nil unless value
-          super.gsub(/(RELATION_ID|NODE_ATTR)\(([^)]+)\)|(REF_DATE|NODE_ID|VISITOR_LANG)/) do
+          super.gsub(/(RELATION_ID|NODE_ATTR|SECURE_TABLE)\(([^)]+)\)|(REF_DATE|NODE_ID|VISITOR_LANG)/) do
             type, value = $1, $2
             type ||= $3
             case type
@@ -367,16 +373,18 @@ module Zena
               if rel = RelationProxy.find_by_role(role.singularize)
                 rel[:id]
               else
-                @errors << "could not find Relation '#{role}' in custom query"
-                '-1'
+                raise ::QueryBuilder::Error.new("Custom query: could not find Relation '#{role}'")
               end
+            when 'SECURE_TABLE'
+              table_name = value
+              add_filter "\#{secure_scope('#{table_name}')}"
             when 'NODE_ATTR'
               attribute = value
               if Node.safe_method_type([attribute])
                 insert_bind("#{node_name}.#{attribute}")
               else
-                @errors << "cannot read attribute '#{attribute}' in custom query"
-                '-1'
+                # not found: consider it's a property
+                insert_bind("#{node_name}.prop[#{attribute.inspect}]")
               end
             when 'REF_DATE'
               context[:ref_date] ? insert_bind(context[:ref_date]) : 'now()'
@@ -480,25 +488,43 @@ module Zena
 
             if class_name
               # We have named the relation, set main_class
+              # We should also insert class filter...
               if klass = Node.get_class(class_name)
                 set_main_class(klass)
+                kpath_filter = ".kpath LIKE #{quote("#{klass.kpath}%")}" unless klass.kpath == 'N'
               else
                 raise QueryBuilder::QueryException.new("Unknown class #{klass} in scope '#{class_name}:#{scope}'.")
               end
+            else
+              klass = nil
             end
 
             if relation == 'start'
               add_table(main_table)
               add_filter "#{field_or_attr('zip')} = #{insert_bind('start_node_zip')}"
               add_filter "#{table}.site_id = #{insert_bind('current_site.id')}"
+              if kpath_filter
+                add_filter "#{table}#{kpath_filter}"
+              end
               return true
             end
 
             if CORE_CONTEXTS.include?(relation)
+              unless class_name
+                if %w{project section}.include?(relation)
+                  set_main_class(VirtualClass[relation.capitalize])
+                else
+                  set_main_class(VirtualClass['Node'])
+                end
+              end
 
               # PREVIOUS_GROUP.id = NEW_GROUP.project_id
               add_table(main_table)
               add_filter "#{field_or_attr('id')} = #{field_or_attr("#{relation}_id", table(main_table, -1))}"
+              if kpath_filter
+                add_filter "#{table}#{kpath_filter}"
+              end
+              true
             else
               nil
             end
@@ -595,9 +621,9 @@ module Zena
               unless @query.select
                 @query.select = ["#{@query.main_table}.*"]
               end
-              add_select "#{link_table}.id AS link_id"
+              add_select("#{link_table}.id", 'link_id')
               Zena::Use::Relations::LINK_ATTRIBUTES.each do |l|
-                add_select "#{link_table}.#{l} AS l_#{l}"
+                add_select("#{link_table}.#{l}", "l_#{l}")
               end
             end
           end

data/lib/zena/use/refactor.rb

@@ -13,9 +13,9 @@ module Zena
         include Common
 
         # Read the parameters and add errors to the object if it is considered spam. Save it otherwize.
-        def save_if_not_spam(obj, params)
+        def should_save(obj, params)
           # do nothing (overwritten by plugins like zena_captcha)
-          obj.save
+          true
         end
 
       end # ControllerMethods
@@ -161,32 +161,6 @@ ENDTXT
           end
           trad_list
         end
-
-        # This lets helpers render partials
-        # TODO: make sure this is the best way to handle this problem.
-        # def render_to_string(*args)
-        #   controller = self.controller || begin
-        #      # ==> this means render_to_string uses a view with everything ApplicationController has...
-        #     ApplicationController.new.instance_eval do
-        #       class << self
-        #         public :render, :render_to_string
-        #         attr_accessor :request, :response, :params
-        #       end
-        #
-        #       @request = ::ActionController::TestRequest.new
-        #       @response = ::ActionController::TestResponse.new
-        #
-        #       @params = {}
-        #       send(:initialize_current_url)
-        #       @template = @response.template = ::ActionView::Base.new(self.class.view_paths, {}, self)
-        #       @template.helpers.send :include, self.class.master_helper_module
-        #       self
-        #     end
-        #   end
-        #
-        #   controller.render(*args)
-        # end
-
       end # ViewMethods
     end # Refactor
   end # Use

data/lib/zena/use/relations.rb

@@ -231,7 +231,7 @@ module Zena
         end
 
         def l_status=(v)
-          @l_status = v.blank? ? nil : v
+          @l_status = v.blank? ? nil : v.to_i
           if rel = relation_proxy_from_link
             rel.other_status = @l_status
           end

data/lib/zena/use/rendering.rb

@@ -3,6 +3,14 @@ require 'tempfile'
 module Zena
   module Use
     module Rendering
+      class Redirect < Exception
+        attr_reader :url
+
+        def initialize(url)
+          @url = url
+        end
+      end # Redirect class
+
       module ViewMethods
         # Append javascript to the end of the page.
         def render_js(in_html = true)
@@ -174,6 +182,16 @@ module Zena
             headers.merge!(zafu_headers)
             cache_page(:url => opts[:cache_url]) if opts[:cache]
           end
+        # This does not work, Rendering::Redirect is wrapped in TemplateError
+        # rescue Zena::Use::Rendering::Redirect
+        # This does not work either: infinity loop, CPU hog on errors.
+        # rescue ActionView::TemplateError => err
+        #   orig = err.original_exception
+        #   if orig.kind_of?(Zena::Use::Rendering::Redirect)
+        #     redirect_to orig.url
+        #   else
+        #     raise err
+        #   end
         end
 
         # Cache page content into a static file in the current sites directory : SITES_ROOT/test.host/public
@@ -277,6 +295,17 @@ module Zena
             out "<% set_headers(#{headers.join(', ')}) %>"
           end
         end
+
+        def r_not_found
+          out "<% raise ActiveRecord::RecordNotFound %>"
+        end
+
+        # Does not work properly. FIXME.
+        # def r_redirect
+        #   out parser_error('Missing "url" parameter.') unless url = @params[:url]
+        #   code = ::RubyLess.translate_string(self, url)
+        #   out "<% raise Zena::Use::Rendering::Redirect.new(#{code}) %>"
+        # end
       end # ZafuMethods
     end # Rendering
   end # Use

data/lib/zena/use/scope_index.rb

@@ -9,16 +9,23 @@ module Zena
 
       module VirtualClassMethods
         def self.included(base)
-          base.validate :validate_idx_class, :validate_idx_scope
-          base.attr_accessible :idx_class
-          base.attr_accessible :idx_scope
+          base.class_eval do
+            validate :validate_idx_class, :validate_idx_scope
+            attr_accessible :idx_class, :idx_scope, :idx_reverse_scope
+            property do |p|
+              p.string 'idx_class'
+              p.string 'idx_scope'
+              p.string 'idx_reverse_scope'
+            end
+            self.export_attributes += %w{idx_class idx_scope idx_reverse_scope}
+          end
         end
 
         protected
           def validate_idx_class
-            self[:idx_class] = nil if self[:idx_class].blank?
+            self.idx_class = nil if self.idx_class.blank?
 
-            if model_name = self[:idx_class]
+            if model_name = self.idx_class
               if model_name =~ /\A[A-Z][a-zA-Z]+\Z/
                 if klass = Zena.const_get(model_name) rescue NilClass
                   if klass < Zena::Use::ScopeIndex::IndexMethods
@@ -36,11 +43,11 @@ module Zena
           end
 
           def validate_idx_scope
-            self[:idx_scope] = nil if self[:idx_scope].blank?
-            if scopes = self[:idx_scope]
+            self.idx_scope = nil if self.idx_scope.blank?
+            if scopes = self.idx_scope
               # Try to compile query in instance of class self
               begin
-                scopes = new_instance.safe_eval self[:idx_scope]
+                scopes = new_instance.safe_eval scopes
                 if scopes.kind_of?(Hash)
                   scopes.each do |keys, query|
                     unless keys.kind_of?(String) &&
@@ -122,11 +129,34 @@ module Zena
           end
         end
 
+        def update_after_destroy(deleted_node, keys)
+          groups = self.class.groups
+          attrs  = {}
+          keys.each do |group_key|
+            next unless list = groups[group_key]
+            next unless should_clear_group?(group_key, deleted_node)
+            list.each do |key|
+              attrs["#{group_key}_#{key}"] = nil
+            end
+          end
+
+          if !attrs.empty?
+            self.attributes = attrs
+            save
+          end
+        end
+
         # Return true if the indices from the given group should be altered by the node.
         def should_update_group?(group_key, node)
           node.id >= self["#{group_key}_id"].to_i
         end
 
+        # Return true if the indices from the given group should be cleared when
+        # the given node is deleted.
+        def should_clear_group?(group_key, deleted_node)
+          deleted_node.id == self["#{group_key}_id"].to_i
+        end
+
         def set_site_id
           self[:site_id] = current_site.id
         end
@@ -134,7 +164,8 @@ module Zena
 
       module ModelMethods
         def self.included(base)
-          base.after_save  :update_scope_indices
+          base.after_save    :update_scope_indices
+          base.after_destroy :update_scope_indices_on_destroy
           base.safe_context :scope_index => scope_index_proc
           base.alias_method_chain :rebuild_index!, :scope_index
         end
@@ -149,7 +180,7 @@ module Zena
           end
         end
 
-        # FIXME: test !
+        # Rebuild 'remote' indexes based on changes in this node.
         def rebuild_index_with_scope_index!
           rebuild_index_without_scope_index!
           update_scope_indices
@@ -171,6 +202,21 @@ module Zena
           end
         end
 
+        # Trigger 'rebuild_index!' in all elements that could affect this model's
+        # scope index.
+        def rebuild_scope_index!
+          if vclass && query = vclass.idx_reverse_scope
+            if nodes = find(:all, query)
+              nodes.each do |node|
+                node.rebuild_index!
+              end
+            end
+          else
+            nil
+          end
+
+        end
+
         protected
           # Update scope indices (project/section).
           def update_scope_indices
@@ -182,7 +228,13 @@ module Zena
              # FIXME: raise when we have transactional save.
           end
 
-          def update_scope_indices_on_prop_change
+          def update_scope_indices_on_destroy
+            update_scope_indices_on_prop_change(true)
+            # How can we handle this ?
+            # update_scope_indices_on_link_change
+          end
+
+          def update_scope_indices_on_prop_change(deleted=false)
             if virtual_class && scopes = virtual_class.idx_scope
               scopes = safe_eval(scopes)
               return unless scopes.kind_of?(Hash)
@@ -198,15 +250,24 @@ module Zena
               mapped_scopes.each do |keys, query|
                 next unless query.kind_of?(String) && keys.kind_of?(Array) && keys.inject(true) {|s,k| s && k.kind_of?(String) }
                 if query.strip == 'self'
+                  next if deleted
                   models_to_update = [self]
                 else
-                  models_to_update = find(:all, query) || []
+                  models_to_update = find(:all, query, :skip_rubyless => true) || []
                 end
 
                 models_to_update.each do |m|
+                  next if m.destroyed? # on destroy, self can be in this list
                   if idx_model = m.scope_index
-                    # force creation of index record
-                    idx_model.update_with(self, keys, true)
+                    if deleted
+                      # Clear obsolete content
+                      idx_model.update_after_destroy(self, keys)
+                      # Rebuild index
+                      m.rebuild_scope_index!
+                    else
+                      # force creation of index record
+                      idx_model.update_with(self, keys, true)
+                    end
                   end
                 end
               end

data/lib/zena/use/search.rb

@@ -10,17 +10,12 @@ module Zena
               :conditions => ["parent_id = ?",node[:id]],
               :order  => 'zip ASC' )
           elsif !query.blank?
-            if Zena::Db.adapter == 'mysql' && RAILS_ENV != 'test'
-              match  = sanitize_sql(["MATCH (vs.idx_text_high,vs.idx_text_medium,vs.idx_text_low) AGAINST (?)", query, "#{options[:name_query] || query.url_name}%"])
-              select = sanitize_sql(["nodes.*, MATCH (vs.idx_text_high,vs.idx_text_medium,vs.idx_text_low) AGAINST (?) AS score", query, "#{query}%"])
-            else
-              match = sanitize_sql(["nodes._id LIKE ?", "#{query}%"])
-              select = "nodes.*, #{match} AS score"
-            end
+            match = sanitize_sql(["vs.idx_text_high LIKE ?", "%#{query.gsub('*','%')}%"])
+            select = "nodes.*"
 
             case Zena::Db.adapter
             when 'postgresql'
-              select = "DISTINCT ON (nodes.zip, score) #{select}"
+              select = "DISTINCT ON (nodes.zip) #{select}"
               group  = nil
             else
               group = 'nodes.id'
@@ -31,7 +26,7 @@ module Zena
               :joins  => "INNER JOIN versions AS vs ON vs.node_id = nodes.id AND vs.status >= #{Zena::Status[:pub]}",
               :conditions => match,
               :group      => group,
-              :order  => "score DESC, zip ASC")
+              :order  => "zip DESC") # new items first
           else
             # error
             return options.merge(:conditions => '0')
@@ -69,7 +64,7 @@ module Zena
 
             query = "nodes where #{query_args.join(' and ')} in site"
           end
-          
+
           res = node.find(count, query, options.merge(:errors => true, :rubyless_helper => self, :default => default))
 
           if res.kind_of?(::QueryBuilder::Error)

data/lib/zena/use/test_helper.rb

@@ -102,7 +102,7 @@ module Zena
         uploaded_fixture(fname, 'image/jpeg', filename)
       end
 
-      # PDF helper
+      # Pdf helper
       def uploaded_pdf(fname, filename=nil)
         uploaded_fixture(fname, 'application/pdf', filename)
       end
@@ -141,7 +141,7 @@ module Zena
         digest = Digest::SHA1.hexdigest(content_id.to_s)
         "#{SITES_ROOT}/test.host/data/#{mode}/#{digest[0..0]}/#{digest[1..1]}/#{digest[2..2]}/#{fname}"
       end
-      
+
       def execute_after_commit!
         Node.connection.instance_eval do
           # Simulate commit