zena 1.0.0.beta3 → 1.0.0.rc1

data/lib/zena.rb

@@ -2,25 +2,50 @@
 require 'yaml'
 require 'date'
 require 'fileutils'
-require File.join(File.dirname(__FILE__), 'zena', 'info')
+require 'zena/info'
+require 'bricks'
+
+SITES_ROOT = "#{RAILS_ROOT}/sites"
+AUTHENTICATED_PREFIX = "oo"
+PASSWORD_SALT = "jf93jfnvnas09093nas0923" # type anything here (but change this line !)
+ZENA_CALENDAR_LANGS = ["en", "fr", "de"] # FIXME: build this dynamically from existing files
+ENABLE_XSENDFILE = false
 
-def has_executable(*list)
-  return false if RUBY_PLATFORM =~ /mswin32/
-  list.inject(true) do |s,e|
-    s && !(`which #{e} || echo 'no #{e}'` =~ /^no #{e}/)
+module Zena
+  def self.has_executable(*list)
+    return false if RUBY_PLATFORM =~ /mswin32/
+    list.inject(true) do |s,e|
+      s && !(`which #{e} || echo 'no #{e}'` =~ /^no #{e}/)
+    end
   end
-end
 
-require 'bricks'
+  ASSET_PORT     = Bricks.raw_config['asset_port']
 
-module Zena
   ENABLE_LATEX   = true  && has_executable('pdflatex') # enable LateX post-rendering
   ENABLE_FOP     = true  && has_executable('fop', 'xsltproc') # enable xsl-fo post-rendering
   ENABLE_MATH    = true  && has_executable('latex', 'dvips', 'convert', 'gs')
 
+  module DbHelper
+  end
+
   # VERSION is defined in root.rb
   class << self
     attr_accessor :tools_enabled
+
+    # Resolve a fully defined constant like 'Bricks::PDF::Engine::Prince'
+    def resolve_const(klass)
+      if klass.kind_of?(String)
+        constant = nil
+        # Foo.const_get('Bar') is not guaranteed to find/load Foo::Bar, it can return just Bar.
+        if klass =~ /\A[^A-Z\:]|[^0-9a-zA-Z\:]/
+          raise NameError.new("Invalid constant name: #{klass.inspect}.")
+        end
+        eval "::#{klass}"
+      else
+        klass
+      end
+    end
+
     def add_load_paths(config = nil)
       paths_to_add = (
         Dir["#{Zena::ROOT}/vendor/gems/*/lib"] +
@@ -28,7 +53,11 @@ module Zena
         Bricks.models_paths
       )
       if config
-        config.load_paths += ["#{Zena::ROOT}/vendor"]
+        ["#{Zena::ROOT}/vendor", "#{Zena::ROOT}/lib"].each do |path|
+          ActiveSupport::Dependencies.load_paths      << path
+          ActiveSupport::Dependencies.load_once_paths << path
+          $LOAD_PATH                                  << path
+        end
       else
         paths_to_add.each do |path|
           $LOAD_PATH.push path
@@ -36,6 +65,10 @@ module Zena
       end
     end
 
+    def log_path
+      "#{RAILS_ROOT}/log/#{RAILS_ENV}.log"
+    end
+
     def enable_tools
       # TODO: move all code from environment.rb here...
       @tools_enabled ||= {:Latex => Zena::ENABLE_LATEX, :fop => Zena::ENABLE_FOP, :math => Zena::ENABLE_MATH}.map{|k,v| v ? k : nil}.compact

data/lib/zena/acts/enrollable.rb

@@ -5,67 +5,58 @@ module Zena
         def self.included(base)
           class << base
             # Pseudo class name
-            attr_accessor :to_s
+            attr_accessor :to_s, :klass
           end
         end
       end
 
-      def self.make_class(klass)
-        if klass.kind_of?(VirtualClass)
-          res_class = Class.new(klass.real_class) do
-            include Named
-          end
-        elsif klass <= Node
-          res_class = Class.new(klass) do
-            include Named
-          end
-        else
-          return klass
-        end
-
-
-        res_class.to_s  = klass.name
-        res_class.kpath = klass.kpath
-
-        res_class.load_roles!
-        res_class
-      end
+      # FIXME: remove all this and simply use VirtualClass['NNP'] in RubyLess:
+      #        write 'safe_method_type' for VirtualClass and forward from there to the real_class
+      # def self.make_class(klass)
+      #   if klass.kind_of?(VirtualClass)
+      #     res_class = Class.new(klass.real_class) do
+      #       include Named
+      #     end
+      #   elsif klass <= Node
+      #     res_class = Class.new(klass) do
+      #       include Named
+      #     end
+      #   else
+      #     return klass
+      #   end
+      #
+      #
+      #   res_class.to_s  = klass.name
+      #   res_class.kpath = klass.kpath
+      #   res_class.klass = klass
+      #
+      #   res_class.load_roles!
+      #   res_class
+      # end
 
       module LoadRoles
-
-        # We overwrite safe_method_type from RubyLess to include the properties loaded
-        # with load_roles!.
+        # FIXME: can we remove or move the 'enroll' stuff to VirtualClass ?
         def safe_method_type(signature, receiver = nil)
-          if signature.size == 1 && (column = loaded_role_properties[signature.first])
-            RubyLess::SafeClass.safe_method_type_for_column(column, true)
-          else
-            super
-          end
-        end
-
-        # Load all possible roles for the current class or instance.
-        def load_roles!
-          return if @roles_loaded
-          load_roles(all_possible_roles)
-          @roles_loaded = true
-        end
-
-        def load_roles(*roles)
-          safe_properties = self.loaded_role_properties
-          roles.flatten.each do |role|
-            has_role role
-            safe_properties.merge!(role.columns)
-          end
-        end
-
-        def all_possible_roles
-          @all_possible_roles ||= begin
-            kpaths = []
-
-            kpath = self.kpath || vclass.kpath
-            kpath.split(//).each_index { |i| kpaths << kpath[0..i] }
-            # FIXME: !! manage a memory cache for Roles
-            Role.all(:conditions => ['kpath IN (?) AND site_id = ?', kpaths, current_site.id], :order => 'kpath ASC')
+          if type = super
+            if type[:enroll]
+              klass = type[:class]
+              if klass.kind_of?(Array)
+                if klass = Enrollable::Common.get_class(klass.first.to_s)
+                  klass = [klass]
+                else
+                  return nil
+                end
+              elsif klass
+                unless klass = Enrollable::Common.get_class(klass.to_s)
+                  return nil
+                end
+              else
+                return nil
+              end
+              type.merge(:class => klass)
+            else
+              type
+            end
           end
         end
       end # LoadRoles
@@ -76,10 +67,22 @@ module Zena
 
           class << base
             attr_accessor :loaded_role_properties
+            attr_accessor :declared_node_contexts, :declared_node_contexts_proc
 
             def loaded_role_properties
               @loaded_role_properties ||= {}
             end
+
+            # Declare a safe context resulting in a (virtual) sub-class of Node. This method
+            # ensures that the returned class will load the Roles available. If you need to
+            # use a virtual-class, you must declare it by using a Symbol or RubyLess will try
+            # to resolve it as a real class resulting in a NameError.
+            def safe_node_context(methods_hash)
+              methods_hash[:defaults] ||= {}
+              methods_hash[:defaults][:nil]    = true
+              methods_hash[:defaults][:enroll] = true
+              safe_method(methods_hash)
+            end
           end
 
           base.class_eval do
@@ -90,17 +93,11 @@ module Zena
               @loaded_role_properties ||= {}
             end
 
-            alias_method_chain :attributes=, :enrollable
-            alias_method_chain :properties=, :enrollable
-            alias_method_chain :rebuild_index!, :enrollable
-
-            before_validation  :check_unknown_attributes
             before_validation  :prepare_roles
             after_save  :update_roles
             after_destroy :destroy_nodes_roles
             has_and_belongs_to_many :roles, :class_name => '::Role'
-            safe_context :possible_roles => {:class => [Role], :method => 'zafu_possible_roles'}
-            safe_context :roles => {:class => [Role], :method => 'zafu_roles'}
+            safe_context :roles  => {:class => [Role], :method => 'assigned_roles'}
 
             property do |p|
               p.serialize :cached_role_ids, Array
@@ -108,18 +105,6 @@ module Zena
           end
         end
 
-        def attributes_with_enrollable=(attrs)
-          load_roles!
-          self.attributes_without_enrollable = attrs
-        rescue ActiveRecord::UnknownAttributeError => err
-          @unknown_attribute_error = err
-        end
-
-        def properties_with_enrollable=(attrs)
-          load_roles!
-          self.properties_without_enrollable = attrs
-        end
-
         def has_role?(role_id)
           if role_id.kind_of?(Fixnum)
             (cached_role_ids || []).include?(role_id)
@@ -128,35 +113,33 @@ module Zena
           end
         end
 
-        def rebuild_index_with_enrollable!
-          load_roles!
-          rebuild_index_without_enrollable!
-        end
-
         def zafu_possible_roles
-          roles = all_possible_roles
+          # Only select database stored roles
+          roles = virtual_class.sorted_roles.select {|r| r.id && r.class == Role }
           roles.empty? ? nil : roles
         end
 
-        def zafu_roles
+        def assigned_roles
           return nil unless role_ids = self.prop['cached_role_ids']
-          # FIXME: memory cache for roles
-          roles = Role.all(:conditions => ['id IN (?) AND site_id = ?', role_ids, current_site.id], :order => 'kpath ASC')
+          roles = (schema.sorted_roles || []).select do |role|
+            role_ids.include?(role.id)
+          end
           roles.empty? ? nil : roles
         end
 
         private
+
           # Do not go any further if the object contains errors
-          def check_unknown_attributes
-            if @unknown_attribute_error
-              name = @unknown_attribute_error.message[%r{unknown attribute: (.+)}, 1]
-              errors.add(name, "unknown attribute")
-              @unknown_attribute_error = nil
-              false
-            else
-              true
-            end
-          end
+          # def check_unknown_attributes
+          #   if @unknown_attribute_error
+          #     name = @unknown_attribute_error.message[%r{unknown attribute: (.+)}, 1]
+          #     errors.add(name, "unknown attribute")
+          #     @unknown_attribute_error = nil
+          #     false
+          #   else
+          #     true
+          #   end
+          # end
 
           # Prepare roles to add/remove to object.
           def prepare_roles
@@ -168,8 +151,10 @@ module Zena
             end
 
             role_ids = []
-            schema.roles.flatten.uniq.each do |role|
-              next unless role.class == Role # Do not index VirtualClasses (information exists through kpath).
+            virtual_class.sorted_roles.each do |role|
+              # Do not index VirtualClasses (information exists through kpath) and do not
+              # index static roles.
+              next unless role.class == Role && role.id
               role_ids << role.id if role.column_names & keys != []
             end
 
@@ -205,12 +190,9 @@ module Zena
       end # ModelMethods
 
       module Common
+        extend self
         def get_class(class_name)
-          if klass = Node.get_class(class_name)
-            Enrollable.make_class(klass)
-          else
-            nil
-          end
+          VirtualClass.find_by_name(class_name)
         end
       end # Common
 

data/lib/zena/acts/secure.rb

@@ -106,21 +106,17 @@ Just doing the above will filter all result according to the logged in user.
 
       # Secure scope for read access
       def secure_scope(table_name)
-        if visitor.is_su?
-          "#{table_name}.site_id = #{visitor.site.id}"
-        else
-          # site_id AND...
-          "#{table_name}.site_id = #{visitor.site.id} AND ("+
-          # READER if published
-          "(#{table_name}.rgroup_id IN (#{visitor.group_ids.join(',')}) AND #{table_name}.publish_from <= #{Zena::Db::NOW} ) OR " +
-          # OR writer
-          "#{table_name}.wgroup_id IN (#{visitor.group_ids.join(',')}))"
-        end
+        # site_id AND...
+        "#{table_name}.site_id = #{visitor.site.id} AND ("+
+        # READER if published
+        "(#{table_name}.rgroup_id IN (#{visitor.group_ids.join(',')}) AND #{table_name}.publish_from <= #{Zena::Db::NOW} ) OR " +
+        # OR writer
+        "#{table_name}.wgroup_id IN (#{visitor.group_ids.join(',')}))"
       end
 
       def secure_write_scope
         scope = {:nodes => {:site_id => visitor.site[:id]}}
-        scope[:nodes] = {:wgroup_id => visitor.group_ids} unless visitor.is_su?
+        scope[:nodes] = {:wgroup_id => visitor.group_ids}
         scope
       end
 
@@ -203,7 +199,7 @@ Just doing the above will filter all result according to the logged in user.
         # * members of +write_group+ if node is published and the current date is greater or equal to the publication date
         def secure_write(obj, &block)
           scope = {:nodes => {:site_id => visitor.site[:id]}}
-          scope[:nodes] = {:wgroup_id => visitor.group_ids} unless visitor.is_su?
+          scope[:nodes] = {:wgroup_id => visitor.group_ids}
           secure_with_scope(obj, scope, &block)
         rescue ActiveRecord::RecordNotFound
           # Rails generated exceptions
@@ -230,13 +226,8 @@ Just doing the above will filter all result according to the logged in user.
         # * owner if +max_status+ <= red
         # * owner if private
         def secure_drive(obj, &block)
-          # scope = if visitor.is_su? # super user
-          #   "site_id = #{visitor.site.id}"
-          # else
-          #   "site_id = #{visitor.site.id} AND dgroup_id IN (#{visitor.group_ids.join(',')})"
-          # end
           scope = { :nodes => {:site_id => visitor.site.id } }
-          scope[:nodes][:dgroup_id] = visitor.group_ids unless visitor.is_su?
+          scope[:nodes][:dgroup_id] = visitor.group_ids
           secure_with_scope(obj, scope, &block)
         rescue ActiveRecord::RecordNotFound
           # Rails generated exceptions
@@ -253,9 +244,6 @@ Just doing the above will filter all result according to the logged in user.
           end
         end
 
-        def driveable?
-          respond_to?(:dgroup_id)
-        end
 
       # This module does two things:
       # 1. make the visitor visit each node
@@ -332,6 +320,22 @@ if defined?(IRB)
   class << self
     include Zena::Acts::Secure
 
+    def err(obj)
+      obj.errors.each_error do |er,msg|
+        puts "[#{er}] #{msg}"
+      end
+    end
+
+    def rename_prop(list, old_key, new_key)
+      list.each do |rec|
+        prop  = rec.prop
+        if value = prop.delete(old_key)
+          prop[new_key] = value
+          Zena::Db.execute "UPDATE #{rec.class.table_name} SET properties=#{Zena::Db.quote(rec.class.encode_properties(prop))} WHERE id=#{rec[:id]}"
+        end
+      end
+    end
+
     def login(name, host = nil)
       finder = {}
       finder[:conditions] = cond = [[]]
@@ -346,7 +350,7 @@ if defined?(IRB)
       cond[0] = cond.first.join(' AND ')
       if visitor = User.find(:first, finder)
         Thread.current[:visitor] = visitor
-        puts "Logged #{visitor.fullname.inspect} (#{visitor.login}) in #{visitor.site.host}"
+        puts "Logged #{visitor.login} in #{visitor.site.host}"
       else
         raise ActiveRecord::RecordNotFound
       end
@@ -358,7 +362,7 @@ if defined?(IRB)
       if zip_or_name.kind_of?(Fixnum)
         secure(Node) { Node.find_by_zip(zip_or_name) }
       else
-        secure(Node) { Node.first(:conditions => ['node_name LIKE ?', "#{zip_or_name}%"]) }
+        secure(Node) { Node.find_by_title(zip_or_name) }
       end
     end
   end

data/lib/zena/acts/secure_node.rb

@@ -25,32 +25,6 @@ module Zena
         before_destroy :secure_on_destroy
 
         include Zena::Acts::SecureNode::InstanceMethods
-
-        class << self
-
-          # kpath is a class shortcut to avoid tons of 'OR type = Page OR type = Document'
-          # we build this path with the first letter of each class. The example bellow
-          # shows how the kpath is built:
-          #           class hierarchy
-          #                Node --> N
-          #       Note --> NN          Page --> NP
-          #                    Document   Form   Section
-          #                       NPD      NPF      NPP
-          # So now, to get all Pages, your sql becomes : WHERE kpath LIKE 'NP%'
-          # to get all Documents : WHERE kpath LIKE 'NPD%'
-          # all pages without Documents : WHERE kpath LIKE 'NP%' AND NOT LIKE 'NPD%'
-          attr_accessor :kpath
-
-          def kpath
-            @kpath ||= make_kpath
-          end
-
-          private
-            def make_kpath
-              superclass.respond_to?(:kpath) ? (superclass.kpath + ksel) : ksel
-            end
-        end
-
         extend  Zena::Acts::SecureNode::ClassMethods
       end
 
@@ -89,7 +63,6 @@ module Zena
         # * members of +read_group+ if the node is published and the current date is greater or equal to the publication date
         # * members of +write_group+
         def can_read?(vis = visitor, ugps=visitor.group_ids)
-          ( vis.is_su? ) || # super user
           ( ugps.include?(rgroup_id) && publish_from && Time.now >= publish_from ) ||
           ( ugps.include?(wgroup_id) )
         end
@@ -98,7 +71,6 @@ module Zena
         # * super user
         # * members of +write_group+ if there status is at least 'user'.
         def can_write?(vis=visitor, ugps=visitor.group_ids)
-          ( vis.is_su? ) ||             # super user
           ( ugps.include?(wgroup_id) && visitor.user?)  # write group
         end
 
@@ -128,43 +100,36 @@ module Zena
         # * super user
         # * members of +drive_group+ if member status is at least 'user'
         def can_drive?(vis=visitor, ugps=visitor.group_ids)
-          ( vis.is_su? ) || # super user
           ( vis.user? && (ugps.include?(dgroup_id) || draft?) )
         end
 
         # 'can_drive?' before attribute change
         def can_drive_was_true?(vis=visitor, ugps=visitor.group_ids)
-          ( vis.is_su? ) || # super user
           ( vis.user? && (ugps.include?(dgroup_id_was) || draft_was_true?) )
         end
 
         # 'can_drive?' without draft? exceptions
         def full_drive?(vis=visitor, ugps=visitor.group_ids)
-          ( vis.is_su? ) || # super user
           ( vis.user? && ugps.include?(dgroup_id) )
         end
 
         # 'full_drive?' before attribute change
         def full_drive_was_true?(vis=visitor, ugps=visitor.group_ids)
-          ( vis.is_su? ) || # super user
           ( vis.user? && ugps.include?(dgroup_id_was) )
         end
-
+        
+        # Secure before validation on create (we use the 'before_validation' hook instead of 'before_validation_on_create'
+        # to trigger secure_before_validation before multiversion's before_validation).
         def secure_before_validation
-          if new_record?
-            secure_before_validation_on_create
-          else
-            secure_before_validation_on_update
-          end
-        end
-
-        def secure_before_validation_on_create
+          return true unless new_record?
+          
+          # Secure before validation on create.
           # set defaults before validation
           self[:site_id]  = visitor.site.id
           self[:user_id]  = visitor.id
           self[:ref_lang] = visitor.lang
 
-          [:rgroup_id, :wgroup_id, :dgroup_id, :skin].each do |sym|
+          [:rgroup_id, :wgroup_id, :dgroup_id, :skin_id].each do |sym|
             # not defined => inherit
             self[sym] ||= ref[sym]
           end
@@ -180,7 +145,6 @@ module Zena
         end
 
         def secure_before_validation_on_update
-          self[:kpath] = self.vclass.kpath if vclass_id_changed? or type_changed?
           true
         end
 
@@ -207,7 +171,7 @@ module Zena
             self[:rgroup_id] = ref.rgroup_id
             self[:wgroup_id] = ref.wgroup_id
             self[:dgroup_id] = ref.dgroup_id
-            self[:skin     ] = ref.skin
+            self[:skin_id  ] = ref.skin_id
           when 0
             # custom access rights
             if ref.full_drive?
@@ -219,7 +183,7 @@ module Zena
               errors.add('rgroup_id', "you cannot change this") unless rgroup_id == ref.rgroup_id
               errors.add('wgroup_id', "you cannot change this") unless wgroup_id == ref.wgroup_id
               errors.add('dgroup_id', "you cannot change this") unless dgroup_id == ref.dgroup_id
-              errors.add('skin' , "you cannot change this") unless skin  == ref.skin
+              errors.add('skin_id' , "you cannot change this") unless skin_id  == ref.skin_id
             end
           else
             errors.add(:inherit, "bad inheritance mode")
@@ -241,7 +205,7 @@ module Zena
             # Node hasn't been changed (only version edits)
             return true
           end
-
+          
           if !can_drive_was_true?
             errors.add(:base, 'You do not have the rights to do this.') unless errors[:base]
             return false
@@ -467,15 +431,6 @@ module Zena
           end
         end
 
-        # kpath selector for the current class
-        def ksel
-          self.to_s[0..0]
-        end
-
-        # Replace Rails subclasses normal behavior
-        def type_condition
-          " #{table_name}.kpath LIKE '#{kpath}%' "
-        end
       end # ClassMethods
 
     end #SecureNode