zena 1.2.7 → 1.2.8

data/lib/zena/use/version_hash.rb

@@ -24,7 +24,7 @@ module Zena
               v_pub = record['publish_from']
 
               if v_pub.kind_of?(String)
-                v_pub = DateTime.parse(record['publish_from']) rescue Time.now
+                v_pub = DateTime.parse(record['publish_from']) rescue Time.now.utc
               end
 
               if n_pub.nil? || v_pub < n_pub
@@ -37,7 +37,10 @@ module Zena
           elsif record['status'].to_i == Zena::Status::Pub
             # ok for readers
             r_hash[lang] = record['id'].to_i
-            v_pub = DateTime.parse(record['publish_from']) rescue Time.now
+            v_pub = record['publish_from']
+            if v_pub.kind_of?(String)   
+              v_pub = DateTime.parse(record['publish_from']) rescue Time.now.utc
+            end
             if n_pub.nil? || v_pub < n_pub
               n_pub = v_pub
             end

data/lib/zena/use/workflow.rb

@@ -12,7 +12,7 @@ module Zena
       module VersionMethods
         attr_reader   :stored_workflow, :status_set
         # Enable the use of version.backup = 'true' to force clone
-        attr_accessor :backup
+        attr_accessor :backup, :no_clone_on_change
 
         def self.included(base)
           base.before_save :store_workflow_changes
@@ -43,20 +43,28 @@ module Zena
 
         # Return true if the version should be cloned if it was changed.
         def clone_on_change?
-          # not same user
-          user_id != visitor.id ||
-          # changed lang
-          lang_changed?         ||
-          # new version on top of publication
-          status_changed?       ||
-          # not in redit time
-          Time.now > created_at + current_site[:redit_time].to_i
+          # List of changed versioned properties
+          if @no_clone_on_change
+            false
+          else
+            # not same user
+            user_id != visitor.id ||
+            # changed lang
+            lang_changed?         ||
+            # new version on top of publication
+            status_changed?       ||
+            # not in redit time
+            Time.now > created_at + current_site[:redit_time].to_i
+          end
         end
 
         # Returns true if the version has been edited (not just a status change)
         def edited?
-          return true if new_record? || (changes.keys - WORKFLOW_ATTRIBUTES != [])
-          return true if node && node.prop.changed?
+          new_record? ||
+          (changes.keys - WORKFLOW_ATTRIBUTES != []) ||
+          # The node loaded here is guaranteed to be the same as the one where props are changed:
+          # node.version.node.object_id == node.object_id
+          nprop.changed?
         end
 
         private
@@ -70,6 +78,10 @@ module Zena
             @status_set = nil
             true
           end
+          
+          def nprop
+            @nprop ||= node.prop
+          end
 
       end
 
@@ -208,14 +220,22 @@ module Zena
             node.can_drive? && !version.edited?
           end
 
+          # This is when destroy goes through version removal.
+          # When destroy is triggered directly, node_before_destroy is used for validation.
           add_transition(:destroy_version,  :from => (-1..Zena::Status::Rep),
                                             :to   => -1) do |node, version|
-            if node.can_drive? && !visitor.is_anon? && (node.versions.count > 1 || node.empty?)
-              true
+            if node.can_drive? && !visitor.is_anon?
+              if node.versions.count > 1
+                true
+              elsif !node.empty?
+                [false, "Cannot destroy last version: node is not empty."]
+              elsif !visitor.is_manager? && node.auth_users
+                [false, "Cannot destroy last version: node is a user."]
+              else
+                true
+              end
             elsif visitor.is_anon?
               [false, "Anonymous users are not allowed to destroy versions."]
-            elsif node.versions.count > 1 || node.empty?
-              [false, "Cannot destroy last version: node is not empty."]
             else
               false
             end
@@ -353,19 +373,6 @@ module Zena
         transition && (transition[:validate].nil? || transition[:validate].call(self, version))
       end
 
-      #def allowed_transitions
-      #  @allowed_transitions ||= begin
-      #    prev_status = version.status_was.to_i
-      #    allowed = []
-      #    self.class.transitions.each do |t|
-      #      if t[:from].include?(prev_status)
-      #        allowed << t if transition_allowed?(t)
-      #      end
-      #    end
-      #    allowed
-      #  end
-      #end
-
       # Returns false is the current visitor does not have enough rights to perform the action.
       def can_apply?(method)
         case method
@@ -375,36 +382,57 @@ module Zena
           can_drive?
         else
           # All the other actions are version transition changes
-          transition_allowed?(method)
+          allowed, msg = transition_allowed?(method)
+          allowed
         end
       end
 
       # Gateway to all modifications of the node or it's versions.
       def apply(method, *args)
-        res = case method
+        case method
         when :update_attributes
           self.attributes = args.first
-          save
         when :propose
           # TODO: replace with version.status = ...
           self.version_attributes = {'status' => args[0] || Zena::Status::Prop}
-          save
         when :publish
           self.version_attributes = {'status' => Zena::Status::Pub}
-          save
         when :refuse, :redit
           self.version_attributes = {'status' => Zena::Status::Red}
-          save
         when :unpublish, :remove
           self.version_attributes = {'status' => Zena::Status::Rem}
-          save
         when :destroy_version
           if versions.count == 1 && empty?
-            self.destroy # will destroy last version
+            return self.destroy # will destroy last version
           else
             self.version_attributes = {:__destroy => true}
+          end
+        else
+          return
+        end
+        
+        if @version
+          # We accessed version, make sure '@node' in version is self
+          @version.instance_variable_set(:@node, self)
+        end
+        
+        # Determine if we need to lock version cloning
+        if @no_clone_on_change || (prop.changed? && !changed_versioned_properties?)
+          # We only lock if properties are changed (not in case of status changes: publication, etc)
+          begin
+            Node.record_timestamps     = false
+            Version.record_timestamps  = false
+            version.no_clone_on_change = true
+            # Make sure indices are rebuilt
             save
+          ensure
+            @no_clone_on_change = nil
+            Node.record_timestamps     = true
+            Version.record_timestamps  = true
+            version.no_clone_on_change = nil
           end
+        else
+          save
         end
       end
 
@@ -487,34 +515,64 @@ module Zena
       end
 
       # Update an node's attributes or the node's version/content attributes. If the attributes contains only
-      # :v_... or :c_... keys, then only the version will be saved. If the attributes does not contain any :v_... or :c_...
-      # attributes, only the node is saved, without creating a new version.
+      # properties, then only the version will be saved. If the attributes does not contain any properties
+      # only the node is saved, without creating a new version.
       def update_attributes(new_attributes)
         apply(:update_attributes, new_attributes)
       end
+      
+      # Used when we want to update properties *without* changing author and/or creating new versions. This
+      # is needed when we want to synchronise some properties with an external application.
+      def update_attributes_without_clone(new_attributes)
+        @no_clone_on_change = true
+        apply(:update_attributes, new_attributes)
+      end
+      
+      # Used when we want to save changed properties *without* changing author and/or creating new versions.
+      # This is needed when we want to synchronise some properties with an external application.
+      def save_without_clone
+        @no_clone_on_change = true
+        apply(:update_attributes, {})
+      end
 
       private
+        def changed_versioned_properties?
+          columns = vclass.db_columns
+          prop.changes.keys.select do |k|
+            if type = columns[k]
+              if type.versioned?
+                return true
+              end
+            else
+              # Properties defined in the model are versioned.
+              return true
+            end
+          end
+          false
+        end
+        
         def set_workflow_defaults
           version = self.version
-
-          # Alter version status or set default value
-          if version.edited? || version.new_record?
-            if version.status_set?
-              if version.status == Zena::Status::Pub &&
-                 version.edited? && !full_drive?
-                # We silently revert to redaction: refuse auto_publish by setting version status.
-                version.status = Zena::Status::Red
+          if !@no_clone_on_change
+            # Alter version status or set default value
+            if version.edited? || version.new_record?
+              if version.status_set?
+                if version.status == Zena::Status::Pub &&
+                   version.edited? && !full_drive?
+                  # We silently revert to redaction: refuse auto_publish by setting version status.
+                  version.status = Zena::Status::Red
+                end
+              else
+                # Set default version status
+                version.status = (auto_publish? && full_drive?) ? Zena::Status::Pub : Zena::Status::Red
               end
             else
-              # Set default version status
-              version.status = (auto_publish? && full_drive?) ? Zena::Status::Pub : Zena::Status::Red
+              # keep status value set
             end
-          else
-            # keep status value set
-          end
 
-          # Set default version's publish_from date
-          version.publish_from = version.status.to_i == Zena::Status::Pub ? (version.publish_from || Time.now) : version.publish_from
+            # Set default version's publish_from date
+            version.publish_from = version.status.to_i == Zena::Status::Pub ? (version.publish_from || Time.now) : version.publish_from
+          end
 
           # Store transition before any validation takes place
           set_current_transition
@@ -532,21 +590,6 @@ module Zena
             else
               errors.add(:base, message || "You do not have the rights to #{transition[:name].to_s.gsub('_', ' ')}.")
             end
-            #unless transition_allowed?(transition)
-            #  if transition_allowed?(transition)
-            #    if [Zena::Status::Prop, Zena::Status::PropWith].include?(@original_version.status)
-            #      errors.add(:base, "You do not have the rights to change a proposition's attributes.")
-            #    else
-            #      errors.add(:base, "You do not have the rights to #{transition[:name].to_s.gsub('_', ' ')} and change attributes.")
-            #    end
-            #  elsif @original_version &&
-            #       (Zena::Status::Prop..Zena::Status::PropWith).include?(@original_version.status) &&
-            #       version.edited?
-            #    errors.add(:base, "You cannot edit while a proposition is beeing reviewed.")
-            #  else
-            #    errors.add(:base, "You do not have the rights to #{transition[:name].to_s.gsub('_', ' ')}.")
-            #  end
-            #end
           elsif version.edited? && (Zena::Status::Prop..Zena::Status::PropWith).include?(version.status_was)
             errors.add(:base, 'You cannot edit while a proposition is beeing reviewed.')
           else
@@ -611,8 +654,11 @@ module Zena
               self.publish_from = get_publish_from(version.id)
             end
           end
-
-          self.updated_at = Time.now unless changed? # force 'updated_at' sync
+          
+          unless version.no_clone_on_change
+            # Do not force updated_at sync when using "update_attributes_without_clone"
+            self.updated_at = Time.now unless changed? # force 'updated_at' sync
+          end
           true
         end
 

data/lib/zena/use/zafu_eval.rb

@@ -1,7 +1,48 @@
 module Zena
   module Use
     module ZafuEval
+      module ViewMethods
+        def zafu_eval(node, code, opts)
+          # Setup macro rendering context
+          if opts[:template]
+            master_template = secure(Node) { Node.find_by_zip(opts[:template]) }
+          end
+          path = opts[:zafu_url]
+          parser = ::Zena::ZafuCompiler.new(code,
+            :helper => self,
+            :base_path        => path,
+            :included_history => [path],
+            :root             => path,
+            :master_template  => master_template
+          )
+          
+          # Setup starting context (note that a lot of the contextual information 
+          # is lost: no up values).
+          _node = node
+          node_context = Zena::Use::NodeContext.new('_node', node.vclass)
+
+          erb = parser.to_erb(
+            :dev => false,
+            :node => node_context,
+            :master_template => master_template
+          )
+          # Geez if this works...
+          ERB.new(erb).result(binding)
+        rescue => err
+          err.message
+        end
+      end
+      
       module ZafuMethods
+        def r_zafu_eval
+          return parser_error("Missing 'code' parameter.") unless code = params[:code]
+          return parser_error("Not a node context.") unless node.will_be?(Node)
+          code = RubyLess.translate(self, code)
+          zafu_url = @options[:root]
+          master   = @context[:master_template]
+          out "<%= zafu_eval(#{node.to_s}, #{code}, :zafu_url => #{zafu_url.inspect}, :template => #{master ? master.zip : 'nil'}) %>"
+        end
+        
         def r_eval
           text = @blocks.first
           if !text.kind_of?(String) || @blocks.size > 1

data/lib/zena/use/zafu_safe_definitions.rb

@@ -186,6 +186,7 @@ module Zena
 
         safe_method_for Range, :to_a       => {:class => [Number]}
 
+        safe_method_for NilClass, :to_s    => {:class => String, :pre_processor => true}
         safe_method_for NilClass, :to_f    => {:class => Number, :pre_processor => true}
         safe_method_for NilClass, :to_i    => {:class => Number, :pre_processor => true}
         safe_method_for NilClass, :to_json => {:class => String, :pre_processor => true}

data/lib/zena/use/zafu_templates.rb

@@ -247,14 +247,31 @@ module Zena
         # Return the path of a template for the given skin, mode and format. Compiles the zafu template if needed.
         def template_url(opts={})
           # opts[:skin] option removed
-          @skin     = get_skin
-          mode      = opts[:mode]
-          format    = opts[:format] || 'html'
-          klass     = @node.vclass
-
-          # possible classes for the master template :
-          kpaths = []
-          klass.kpath.split(//).each_index { |i| kpaths << klass.kpath[0..i] }
+          if vclass = opts[:vclass]
+            # We know the skin title, skip 'get_skin'
+            @skins ||= {}
+            
+            if opts[:skin].to_s =~ /^\$(.*)/
+              # The skin passed through the url is $brick-bar if using fs_skin and this does not work.
+              @skin = @skins[opts[:skin]] ||= secure(Skin) { visitor.site.root_node.find("skin where z_fs_skin = '#{$1}' in site") }
+            else
+              @skin = @skins[opts[:skin]] ||= secure(Skin) { Skin.find_by_title(opts[:skin]) }
+            end
+            
+            # possible classes for the master template :
+            kpaths = [vclass.kpath]
+          else
+            @skin  = get_skin
+            vclass = @node.vclass
+            
+            # possible classes for the master template :
+            kpaths = []
+            vclass.kpath.split(//).each_index { |i| kpaths << vclass.kpath[0..i] }
+          end
+          
+          mode   = opts[:mode]
+          mode   = nil if mode.blank?
+          format = opts[:format] || 'html'
 
           if @skin
             zafu_url, template = get_best_template(kpaths, format, mode, @skin)
@@ -264,11 +281,8 @@ module Zena
             
             path      = SITES_ROOT + rel_path
             if !File.exists?(path) || params[:rebuild]
-              if @node && klass = VirtualClass.find_by_kpath(template.tkpath)
-                zafu_node('@node', klass)
-              else
-                nil
-              end
+              # Use the template's target vclass as starting context
+              zafu_node('@node', VirtualClass.find_by_kpath(template.tkpath))
 
               # template is a new record when template is returned for
               # a static file.
@@ -320,7 +334,7 @@ module Zena
           end
 
           template_url = template_url.split('/')
-          base_p = ['', current_site.host, 'zafu'] + template_url[0..-2]
+          base_p = [current_site.zafu_path] + template_url[0..-2]
           lang_p = [dev_mode? ? "dev_#{lang}" : lang]
           part_p = template_url[-1]
           
@@ -328,21 +342,13 @@ module Zena
           if !File.exist?(main_fullpath) && build
             skin = template_url[0]
             template_name = template_url[-2]
+            
             if template_name =~ ::Template::MODE_FORMAT_FROM_TITLE
-              # title changed force  update
               klass  = $1
               mode   = $4 || ''
               format = $6 || 'html'
-              # Template rendering node
-              node_bak = @node
-                # Find first node matching klass
-                vclass = VirtualClass[klass]
-                @node = Node.sfind("#{klass.underscore} in site", :first)
-                if @node.skin.title != skin
-                  @node.skin = secure(Skin) { Skin.find_by_title(skin) }
-                end
-                template_url(:mode => mode, :format => format)
-              @node = node_bak
+              
+              template_url(:mode => mode, :format => format, :vclass => VirtualClass[klass], :skin => skin)
             end
           end
           
@@ -451,7 +457,7 @@ module Zena
                 end
               end
             end
-
+            
             res = ZafuCompiler.new_with_url(zafu_url, :helper => zafu_helper).to_erb(:dev => dev_mode?, :node => get_node_context, :master_template => template)
             
             unless valid_template?(res, opts)