spiderfw 0.5.9 → 0.5.10

data/lib/spiderfw/cmd/commands/{init.rb → create.rb}

@@ -1,10 +1,10 @@
 require 'spiderfw/create'
 
-class InitCommand < CmdParse::Command
+class CreateCommand < CmdParse::Command
 
 
     def initialize
-        super( 'init', true, true )
+        super( 'create', true, true )
         @short_desc = _("Create a working dir for development or installation")
 #        @description = _("")
 
@@ -29,7 +29,7 @@ class InitCommand < CmdParse::Command
         end
         self.add_command(app, false)
         
-        install = CmdParse::Command.new('install', false)
+        install = CmdParse::Command.new('home', false)
         install.short_desc = _("Create an installation")
         install.options = CmdParse::OptionParserWrapper.new do |opt|
             opt.on("--path", 
@@ -41,7 +41,7 @@ class InitCommand < CmdParse::Command
         install.set_execution_block do |installs|
             @path ||= Dir.pwd
             installs.each do |inst|
-                Spider::Create.install(inst, @path)
+                Spider::Create.home(inst, @path)
             end
         end
         self.add_command(install, false)

data/lib/spiderfw/config/options/spider.rb

@@ -31,6 +31,10 @@ module Spider
     config_option 'webserver.force_threads', _("Force threading on non-threaded adapters"),
         :default => Proc.new{ RUBY_VERSION_PARTS[1] == '8' ? true : false }
     config_option 'webserver.timeout', _("Time allowed for each request (in seconds)"), :type=> Fixnum, :default => nil
+    config_option 'static_content.mode', _("Mode to use for serving static files"), :type => String,
+        :choices => [nil, 'x-sendfile', 'x-accel-redirect', 'published'], :default => nil
+    config_option 'static_content.auto_publish', _("Automatically publish content to the home's public folder"),
+        :type => Spider::DataTypes::Bool, :default => false
     # Client
     config_option 'client.text_editor', _("The text editor installed on the client")
     

data/lib/spiderfw/controller/controller.rb

@@ -54,7 +54,17 @@ module Spider
                 return self.app.path+'/views'
             end
         
-            
+            # Defines a method that will be called before the controller's before,
+            # if the action matches the given conditions.
+            # - The first argument, the condition(s), may be a String, a Regexp, a Proc or a Symbol,
+            # that will be checked against the action, or an Array containing several conditions.
+            # - The second argument, a Symbol, is the method to be called if the conditions match.
+            # - The third optional argument, an Hash, may contain :unless => true: in this case,
+            # the conditions will be inverted, that is, the method will be executed unless the conditions
+            # match.
+            # Example:
+            #   before('list_', :before_lists)
+            # will call the method before_lists if the action starts with 'list_'
             def before(conditions, method, params={})
                 @dispatch_methods ||= {}
                 @dispatch_methods[:before] ||= []

data/lib/spiderfw/controller/dispatcher.rb

@@ -238,6 +238,8 @@ module Spider
                         return true if (action == check || (action[-1].chr == '/' && action[0..-2] == check))
                     elsif check.is_a?(Regexp)
                         return true if action =~ check
+                    elsif check.is_a?(Proc)
+                        return true if check.call(action)
                     elsif (check.is_a?(Symbol))
                         first, rest = action.split('/', 2)
                         return true if first && first.to_sym == check

data/lib/spiderfw/controller/home_controller.rb

@@ -18,7 +18,13 @@ module Spider
 
         def self.pub_url
             HTTPMixin.reverse_proxy_mapping('/public')
-        end  
+        end
+        
+        def self.app_pub_path(app=nil)
+            path = self.pub_path+'/apps'
+            path += '/'+app.short_name if app
+            path
+        end
 
     end
 

data/lib/spiderfw/controller/mixins/static_content.rb

@@ -50,6 +50,12 @@ module Spider; module ControllerMixins
             path += ".#{@request.format}" if @request.format
             raise Spider::Controller::NotFound.new(path) unless path
             path = sanitize_path(path)
+            mode = Spider.conf.get('static_content.mode')
+            if mode == 'publish' && self.class != Spider::HomeController
+                url = self.pub_url
+                url += "/"+path
+                return redirect(url)
+            end
             full_path = pub_path+'/'+path
             raise Spider::Controller::NotFound.new(path) unless File.exist?(full_path)
             output_static(full_path)
@@ -66,6 +72,7 @@ module Spider; module ControllerMixins
         
         def output_static(full_path)
             debug("Serving asset: #{full_path}")
+            mode = Spider.conf.get('static_content.mode')
             raise Spider::Controller::NotFound.new(full_path) unless File.exist?(full_path)
             stat = File.lstat(full_path)
             if File.directory?(full_path)
@@ -78,9 +85,16 @@ module Spider; module ControllerMixins
             @response.headers['Content-Type'] = ct
             @response.headers['Content-Length'] = stat.size
             @response.headers['Last-Modified'] = stat.mtime.httpdate
-            f = File.open(full_path, 'r')
-            while (block = f.read(1024)) do
-                $out << block
+            
+            if mode == 'x-sendfile'
+                @response.headers['X-Sendfile'] = full_path
+            elsif mode == 'x-accel-redirect'
+                @response.headers['X-Accel-Redirect'] = full_path
+            else
+                f = File.open(full_path, 'r')
+                while (block = f.read(1024)) do
+                    $out << block
+                end
             end
         end
         

data/lib/spiderfw/controller/mixins/visual.rb

@@ -5,7 +5,7 @@ module Spider; module ControllerMixins
     
     # Mixin for objects using templates
     module Visual
-        
+        attr_reader :template
         attr_accessor :layout, :dispatcher_layout
         
         def self.included(klass)
@@ -68,7 +68,6 @@ module Spider; module ControllerMixins
                 first, rest = widget_target.split('/', 2)
                 @_widget = find_widget(first)
                 raise Spider::Controller::NotFound.new("Widget #{widget_target}") unless @_widget
-                @is_target = false
                 @_widget.is_target = true unless rest
                 @_widget.set_action(widget_execute) if widget_execute
                 @_widget.target_mode = true
@@ -83,6 +82,7 @@ module Spider; module ControllerMixins
         
         def execute(action='', *params)
             @visual_params = @executed_format_params
+            @is_target = false if @request.params['_wt']
             if (self.is_a?(Widget) && @is_target && @request.params['_wp'])
                 params = @request.params['_wp']
             elsif (@visual_params.is_a?(Hash) && @visual_params[:params])

data/lib/spiderfw/controller/session.rb

@@ -56,6 +56,8 @@ module Spider
         
         def []=(key, val)
             restore unless @restored
+            raise "You can't overwrite the :_flash Hash" if key == :_flash
+            raise "You can't overwrite the :_transient Hash" if key == :_transient
             @data[key] = val
         end
         

data/lib/spiderfw/create.rb

@@ -28,9 +28,9 @@ module Spider
             create(source_folder, dest_folder, replacements, erb_binding)
         end
         
-        def self.install(name, path)
+        def self.home(name, path)
             dest_path = path+'/'+name
-            source_path = $SPIDER_PATH+'/blueprints/install'
+            source_path = $SPIDER_PATH+'/blueprints/home'
             create(source_path, dest_path)
         end
         

data/lib/spiderfw/model/base_model.rb

@@ -53,6 +53,7 @@ module Spider; module Model
     class BaseModel
         include Spider::Logger
         include DataTypes
+        include Spider::QueryFuncs
         # include StateMachine
         
         # The BaseModel class itself. Used when dealing with proxy objects.
@@ -167,6 +168,8 @@ module Spider; module Model
         # :read_only::                (bool) hint to the UI that the element should not be user modifiable.
         # :owned::                    (bool) only this model holds references to type
         # :condition::                (hash or Condition) Restricts an association always adding the condition.
+        # :order::                    (true or Fixnum) When doing queries, sort by this element. More than one element can have the
+        #                             :order attribute; if it is a Fixnum, it will mean the position in the ordering.
         # 
         # Other attributes may be used by DataTypes (see #DataType::ClassMethods.take_attributes), and other code.
         # See also Element.
@@ -503,6 +506,7 @@ module Spider; module Model
                     attributes.delete(:add_multiple_reverse)
                 end
                 attributes.delete(:primary_key) unless (params[:keep_pks])
+                attributes.delete(:required)
                 name = params[:mapping] && params[:mapping][el.name] ? params[:mapping][el.name] : el.name
                 element(name, el.type, attributes)
             end
@@ -1756,6 +1760,13 @@ module Spider; module Model
             mapper.delete_element_associations(self, element, object)
         end
         
+        # Method that will be called by the mapper before a query. May be overridden to preprocess the query.
+        # Must return the modified query. Note: to prepare conditions, use prepare_condition, since it will
+        # be called on subconditions as well.
+        def self.prepare_query(query)
+            query
+        end
+        
         ##############################################################
         #   Method missing                                           #
         ##############################################################

data/lib/spiderfw/model/condition.rb

@@ -125,7 +125,16 @@ module Spider; module Model
         # Yields each key, value and comparison.
         def each_with_comparison
             self.each do |k, v|
-                yield k, v, @comparisons[k.to_sym] || '='
+                k = k.to_sym if k.respond_to?(:to_sym)
+                yield k, v, @comparisons[k] || '='
+            end
+        end
+        
+        # Yields each key, value and comparison, for this condition and its subconditions
+        def all_each_with_comparison
+            self.each_with_comparison{ |k, v, c| yield k, v, c }
+            @subconditions.each do |sub|
+                sub.all_each_with_comparison{ |k, v, c| yield k, v, c }
             end
         end
         
@@ -164,10 +173,13 @@ module Spider; module Model
                 @subconditions << or_cond
                 return self
             end
-            field = field.to_s
-            parts = field.split('.', 2)
-            parts[0] = parts[0].to_sym
-            field = field.to_sym unless parts[1]
+            parts = []
+            unless field.is_a?(Spider::QueryFuncs::Function)
+                field = field.to_s
+                parts = field.split('.', 2)
+                parts[0] = parts[0].to_sym
+                field = field.to_sym unless parts[1]
+            end
             if (parts[1])
                 hash_set(parts[0], get_deep_obj()) unless self[parts[0]]
                 self[parts[0]].set(parts[1], comparison, value)
@@ -190,7 +202,8 @@ module Spider; module Model
         def [](key)
             # TODO: deep
             key = key.name if key.class == Element
-            super(key.to_sym)
+            key = key.to_sym if key.respond_to?(:to_sym) # might be a QueryFunc
+            super(key)
         end
         
         # Adds a range condition. This creates a subcondition with >= and <= conditions.
@@ -203,8 +216,12 @@ module Spider; module Model
         
         # Deletes a field from the Condition.
         def delete(field)
+            field = field.to_sym
+            return nil unless self[field] || @comparisons[field]
+            cur = [self[field], @comparisons[field]]
             super
-            @comparisons.delete(field.to_sym)
+            @comparisons.delete(field)
+            cur
         end    
         
         # Parses a string comparison.
@@ -343,6 +360,19 @@ module Spider; module Model
             pol << @polymorph if @polymorph
             return pol + @subconditions.inject([]){ |arr, s| arr += s.polymorphs }
         end
+        
+        # Returns, from self and subconditions, all those who define a condition for one of the given element names.
+        def conditions_for(*element_names)
+            conds = []
+            element_names.each do |el|
+                if self[el]
+                    conds << self
+                    break
+                end
+            end
+            @subconditions.map{ |s| s.conditions_for(*element_names) }.each{ |c| conds += c }
+            conds
+        end
     
     end
     

data/lib/spiderfw/model/mappers/db_mapper.rb

@@ -136,7 +136,7 @@ module Spider; module Model; module Mappers
             @model.primary_keys.each do |key|
                 condition[key.name] = map_condition_value(key.type, obj.get(key))
             end
-            prepare_query_condition(condition)
+            preprocess_condition(condition)
             save[:condition], save[:joins] = prepare_condition(condition)
             save[:joins] = prepare_joins(save[:joins])
             save[:table] = @schema.table
@@ -148,7 +148,7 @@ module Spider; module Model; module Mappers
             db_values = {}
             joins = []
             integrated = {}
-            condition = prepare_query_condition(condition)
+            condition = preprocess_condition(condition)
             values.each do |key, val|
                 element = @model.elements[key]
                 if (element.integrated?)
@@ -299,7 +299,6 @@ module Spider; module Model; module Mappers
         
         # Returns true if an element can be loaded joined-in.
         def can_join?(element)
-            return false if element.multiple?
             return false if element.storage != @storage
             return true
         end
@@ -471,60 +470,47 @@ module Spider; module Model; module Mappers
         #--
         # TODO: better name for :values
         def prepare_condition(condition, options={})
-            # FIXME: move to mapper
             model = condition.polymorph ? condition.polymorph : @model
             model_schema = model.mapper.schema
             cond = {}
-            # debugger if condition.polymorph
-            condition.each_with_comparison do |k, v, comp|
-                # normalize condition values
-                element = model.elements[k.to_sym]
-                if (v && !v.is_a?(Condition) && element.model?)
-                    condition.delete(element.name)
-                    def set_pks_condition(condition, el, val, prefix)
-                        el.model.primary_keys.each do |primary_key|
-                            new_prefix = "#{prefix}.#{primary_key.name}"
-                            if (primary_key.model?)
-                                if (primary_key.model.primary_keys.length == 1)
-                                    # FIXME: this should not be needed, see below
-                                    condition.set(new_prefix, '=', val.get(primary_key).get(primary_key.model.primary_keys[0]))
-                                else
-                                    # FIXME! does not work, the subcondition does not get processed
-                                    raise "Subconditions on multiple key elements not supported yet"
-                                    subcond = Condition.new
-                                    set_pks_condition(subcond,  primary_key, val.get(primary_key), new_prefix)
-                                    condition << subcond
-                                end
-                            else
-                                condition.set(new_prefix, '=', val.get(primary_key))
-                            end
-                        end
-                    end
-                    if v.is_a?(BaseModel)
-                        set_pks_condition(condition, element, v, element.name)
-                    elsif element.model.primary_keys.length == 1 
-                        new_v = Condition.new
-                        if (model.mapper.have_references?(element.name))
-                            new_v.set(element.model.primary_keys[0].name, comp, v)
-                        else
-                            new_v.set(element.reverse, comp, v)
-                        end
-                        condition.set(element.name, comp, new_v)
-                    else
-                        raise MapperError, "Value condition passed on #{k}, but #{element.model} has more then one primary key"
-                    end
-                end
-            end 
+
             bind_values = []
             joins = options[:joins] || []
             remaining_condition = Condition.new # TODO: implement
             cond[:conj] = condition.conjunction.to_s
             cond[:values] = []
+            
+            # find out which elements have non nil conditions to figure out joins
+            def get_not_nil(model, condition, not_nil)
+                condition.all_each_with_comparison do |k, v, comp|
+                    next unless k.respond_to?(:to_sym)
+                    element = model.elements[k.to_sym]
+                    next unless element
+                    next unless model.mapper.mapped?(element)
+                    next unless element.model?
+                    not_nil[k] = {} if !v.nil? || comp != '='
+                    get_not_nil(element.model, v, not_nil[k]) if v.is_a?(Condition)
+                end
+            end
+            
+            not_nil = options[:not_nil]
+            unless not_nil
+                not_nil = {}
+                get_not_nil(@model, condition, not_nil)
+            end
+                        
             condition.each_with_comparison do |k, v, comp|
+                if k.is_a?(QueryFuncs::Function)
+                    field = prepare_queryfunc(k)
+                    cond[:values] << [field, comp, v]
+                    joins += field.joins
+                    next
+                end
                 element = model.elements[k.to_sym]
                 next unless model.mapper.mapped?(element)
                 if (element.model?)
-                    if (v && model.mapper.have_references?(element.name) && v.select{ |key, value| !element.model.elements[key].primary_key? }.empty?)
+                    if (v && model.mapper.have_references?(element.name) && v.select{ |key, value| 
+                        !element.model.elements[key] || !element.model.elements[key].primary_key? }.empty?)
                         # 1/n <-> 1 with only primary keys
                         element_cond = {:conj => 'AND', :values => []}
                         v.each_with_comparison do |el_k, el_v, el_comp|
@@ -537,11 +523,7 @@ module Spider; module Model; module Mappers
                         cond[:values] << element_cond
                     else
                         if (element.storage == model.mapper.storage)
-                            if v.nil?
-                                join_type = comp == '=' ? :left : :inner
-                            else
-                                join_type = :inner
-                            end
+                            join_type = (v.nil? && comp == '=') ? :left : :inner
                             sub_join = model.mapper.get_join(element, join_type)
                             # FIXME! cleanup, and apply the check to joins acquired in other places, too (maybe pass the current joins to get_join)
                             existent = joins.select{ |j| j[:to] == sub_join[:to] }
@@ -560,17 +542,25 @@ module Spider; module Model; module Mappers
                             sub_join[:as] = "#{sub_join[:to]}#{j_cnt}" if j_cnt
                             joins << sub_join unless had_join
                             
-                            if v.nil? && comp == '='
+                            if v.nil? && comp == '=' && !not_nil[element.name]
                                 element_cond = {:conj => 'AND', :values => []}
-                                element.model.primary_keys.each do |k|
-                                    field = model_schema.qualified_foreign_key_field(element.name, k.name)
+                                    if model.mapper.have_references?(element.name)
+                                    el_name = element.name
+                                    el_model = element.model
+                                else
+                                    el_model = element.type
+                                    model_schema = element.model.mapper.schema 
+                                    el_name = element.attributes[:junction_their_element]
+                                end
+                                el_model.primary_keys.each do |k|
+                                    field = model_schema.qualified_foreign_key_field(el_name, k.name)
                                     field_cond = [field, comp,  map_condition_value(element.model.elements[k.name].type, nil)]
                                     element_cond[:values] << field_cond
                                 end
                                 cond[:values] << element_cond
                             elsif v
-                                element.model.mapper.prepare_query_condition(v)                            
-                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :joins => joins)
+                                v = element.model.mapper.preprocess_condition(v)                          
+                                sub_condition, sub_joins = element.mapper.prepare_condition(v, :table => sub_join[:as], :joins => joins, :not_nil => not_nil[element.name])
                                 sub_condition[:table] = sub_join[:as] if sub_join[:as]
                                 joins = sub_joins
                                 cond[:values] << sub_condition
@@ -597,7 +587,7 @@ module Spider; module Model; module Mappers
             sub_sqls = []
             sub_bind_values = []
             condition.subconditions.each do |sub|
-                sub_res = self.prepare_condition(sub, :joins => joins)
+                sub_res = self.prepare_condition(sub, :joins => joins, :not_nil => not_nil)
                 cond[:values] << sub_res[0]
                 joins = sub_res[1]
                 remaining_condition += sub_res[2]
@@ -605,6 +595,7 @@ module Spider; module Model; module Mappers
             return [cond, joins, remaining_condition]
         end
 
+
         # Figures out a join for element. Returns join hash description, i.e. :
         #   join = {
         #     :type => :inner|:outer|...,
@@ -615,11 +606,11 @@ module Spider; module Model; module Mappers
         #   }
         def get_join(element, join_type = :inner)
             return unless element.model?
-            Spider::Logger.debug("Getting join for model #{@model} to element #{element}")
-            Spider::Logger.debug(@model.primary_keys.map{|k| k.name})
+            #Spider::Logger.debug("Getting join for model #{@model} to element #{element}")
+            #Spider::Logger.debug(@model.primary_keys.map{|k| k.name})
             element_table = element.mapper.schema.table
             if (schema.has_foreign_fields?(element.name))
-                Spider::Logger.debug("JOIN A from #{@model} to #{element.name}")
+                #Spider::Logger.debug("JOIN A from #{@model} to #{element.name}")
                 keys = {}
                 element.model.primary_keys.each do |key|
                     if (key.integrated?)
@@ -631,7 +622,6 @@ module Spider; module Model; module Mappers
                     end
 
                     fk = schema.foreign_key_field(element.name, key.name)
-                    fk = fk.expression if fk.is_a?(FieldExpression)
                     keys[fk] = el_field
                     # FIXME: works with models as primary keys through a hack in the field method of db_schema,
                     # assuming the model has only one key. the correct way would be to get another join
@@ -652,7 +642,7 @@ module Spider; module Model; module Mappers
                     :as => as
                 }
             elsif (element.has_single_reverse? && element.mapper.schema.has_foreign_fields?(element.reverse)) # n/1 <-> n
-                Spider::Logger.debug("JOIN B from #{@model} to #{element.name}")
+                #Spider::Logger.debug("JOIN B from #{@model} to #{element.name}")
                 keys = {}
                 @model.primary_keys.each do |key|
                     our_field = nil
@@ -662,7 +652,6 @@ module Spider; module Model; module Mappers
                         our_field = schema.field(key.name)
                     end
                     keys[our_field] = element.mapper.schema.foreign_key_field(element.reverse, key.name)
-                    keys[our_field] = keys[our_field].expression if keys[our_field].is_a?(FieldExpression)
                 end
                 if (element.condition)
                     condition, condition_joins, condition_remaining = element.mapper.prepare_condition(element.condition)
@@ -695,6 +684,7 @@ module Spider; module Model; module Mappers
             Spider::Logger.debug("GETTING DEEP JOIN TO #{dotted_element} (#{@model})")
             parts.each do |part|
                 el = current_model.elements[part]
+                raise "Can't find element #{part} in model #{current_model}" unless el
                 if (el.integrated?)
                     joins << current_model.mapper.get_join(el.integrated_from)
                     current_model = el.integrated_from.type
@@ -714,6 +704,18 @@ module Spider; module Model; module Mappers
             return [joins, current_model, el]
         end
         
+        def prepare_queryfunc(func)
+            joins = []
+            func_elements = func.inner_elements
+            func_elements.each do |el_name, owner_func|
+                el_joins, el_model, el = get_deep_join(el_name)
+                joins += el_joins
+                owner_func.mapper_fields ||= {}
+                owner_func.mapper_fields[el.name] = el_model.mapper.schema.field(el.name)
+            end
+            return FieldFunction.new(storage.function(func), schema.table, joins)
+        end
+        
         # Takes a Spider::QueryFuncs::Expression, and associates the fields to the corresponding elements
         # Returns an array of needed joins
         def prepare_expression(expr)
@@ -737,15 +739,8 @@ module Spider; module Model; module Mappers
                 order_element, direction = order
                 el_model = @model
                 if (order_element.is_a?(QueryFuncs::Function))
-                    func_fields = []
-                    func_elements = order_element.inner_elements
-                    func_elements.each do |el_name, owner_func|
-                        el_joins, el_model, el = get_deep_join(el_name)
-                        joins += el_joins
-                        owner_func.mapper_fields ||= {}
-                        owner_func.mapper_fields[el.name] = el_model.mapper.schema.field(el.name)
-                    end
-                    field = storage.function(order_element)
+                    field = prepare_queryfunc(order_element)
+                    joins += field.joins
                     fields << [field, direction]
                 else
                     el_joins, el_model, el = get_deep_join(order_element)
@@ -761,6 +756,7 @@ module Spider; module Model; module Mappers
                             end
                         end
                     else
+                        raise "Order on unmapped element #{el_model.name}.#{el.name}" unless el_model.mapper.mapped?(el)
                         field = el_model.mapper.schema.field(el.name)
                         fields << [field, direction]
                     end