spiderfw 0.5.9 → 0.5.10

data/apps/core/components/public/js/jquery/plugins/jtree/jquery.jtree.spider.1.0.js

@@ -0,0 +1,193 @@
+// JavaScript Document
+(function($) {
+
+	$.fn.jTree = function(options) {
+		var opts = $.extend({}, $.fn.jTree.defaults, options);
+		var cur = 0, curOff = 0, off =0, h =0, w=0, hover = 0;
+		var str='<li class="jTreePlacement" style="background:'+opts.pBg+';border:'+opts.pBorder+';color:'+opts.pColor+';height:'+opts.pHeight+'"></li>';
+		var container = this;
+		$("body").append(str);
+		$(".jTreePlacement").hide();
+		//events are written here
+		$(this).find("li").draggable({
+			start: function(){
+				
+			}
+		})
+		$(this).find("li").mousedown(function(e){
+			if ($("#jTreeHelper").is(":not(:animated)") && e.button !=2) {
+				// append jTreePlacement to body and hides
+				
+				//get the current li and append to helper
+				$(this).clone().appendTo("#jTreeHelper");
+				
+				// get initial state, cur and offset
+				cur = this;
+				curOff = $(cur).offset();
+				$(cur).hide();
+				// show initial helper
+				$("#jTreeHelper").css ({
+					position: "absolute",
+					top: e.pageY + 5,
+					left: e.pageX + 5,
+					background: opts.hBg,
+					opacity: opts.hOpacity
+				}).show();
+				$("#jTreeHelper *").css ({
+					color: opts.hColor,
+					background: opts.hBg
+				});
+				// start binding events to use
+				// prevent text selection
+				$(document).bind("selectstart", doNothing);
+				
+				// doubleclick is destructive, better disable
+				$(container).find("li").bind("dblclick", doNothing);
+				
+				// in single li calculate the offset, width height of hovered block
+				$(container).find("li").bind("mouseover", getInitial);
+				
+				// in single li put placement in correct places, also move the helper around
+				$(container).find("li").bind("mousemove", putPlacement);
+				
+				// handle mouse movement outside our container
+				$(document).bind("mousemove", helperPosition);
+			}
+			//prevent bubbling of mousedown
+			return false;
+		});
+		
+		// in single li or in container, snap into placement if present then destroy placement
+		// and helper then show snapped in object/li
+		// also destroys events
+		$(this).find("li").andSelf().mouseup(function(e){
+			// if placementBox is detected
+			if ($(".jTreePlacement").is(":visible")) {
+				$(cur).insertBefore(".jTreePlacement").show();
+			}
+			$(cur).show();
+			// remove helper and placement box
+			$(container).find("ul:empty").remove();
+			$("#jTreeHelper").empty().hide();
+			$(".jTreePlacement").remove();		
+			
+			// remove bindings
+			destroyBindings();
+			
+			return false;
+		});
+		
+		$(document).mouseup(function(e){
+			if (cur!=0) {
+				$("#jTreeHelper").animate({
+					top: curOff.top,
+					left: curOff.left
+						}, opts.snapBack, function(){
+							$("#jTreeHelper").empty().hide();
+							$(".jTreePlacement").remove();
+							$(cur).show();
+						}
+				);
+				destroyBindings();
+			}
+			cur = 0;
+			return false;
+		});
+		//functions are written here
+		var doNothing = function(){
+			return false;
+		};
+		
+		var destroyBindings = function(){
+			$(document).unbind("selectstart", doNothing);
+			$(container).find("li").unbind("dblclick", doNothing);
+			$(container).find("li").unbind("mouseover", getInitial);
+			$(container).find("li").unbind("mousemove", putPlacement);
+			$(document).unbind("mousemove", helperPosition);
+		};
+		
+		var helperPosition = function(e) {
+			$("#jTreeHelper").css ({
+				top: e.pageY + 5,
+				left: e.pageX + 5
+			});
+			
+			$(".jTreePlacement").remove();
+		};
+		
+		var getInitial = function(e){
+			off = $(this).offset();
+			h = $(this).height();
+			w = $(this).width();
+			hover = this;
+			return false;
+		};
+		
+		var putPlacement = function(e){
+			$(cur).hide();
+			$("#jTreeHelper").css ({
+				top: e.pageY + 5,
+				left: e.pageX + 5
+			});
+	
+			//inserting before
+			if ( e.pageY >= off.top && e.pageY < (off.top + h/2 - 1) ) {
+				if (!$(this).prev().hasClass("jTreePlacement")) {
+					$(".jTreePlacement").remove();
+					$(this).before(str);
+				}
+			}
+			//inserting after
+			else if (e.pageY >(off.top + h/2) &&  e.pageY <= (off.top + h) ) {
+				// as a sibling
+				if (e.pageY > off.left && e.pageX < off.left + opts.childOff) {
+					if (!$(this).next().hasClass("jTreePlacement")) {
+						$(".jTreePlacement").remove();
+						$(this).after(str);
+					}
+				}
+				// as a child
+				else if (e.pageX > off.left + opts.childOff) {
+					
+					$(".jTreePlacement").remove();
+					if ($(this).find("ul").length == 0)
+						$(this).append('<ul>'+str+'</ul>');
+					else
+						$(this).find("ul").prepend(str);
+				}
+			}
+			return false;
+		};
+		
+		var lockIn = function(e) {
+			// if placement box is present, insert before placement box
+			if ($(".jTreePlacement").length==1) {
+				$(cur).insertBefore(".jTreePlacement");
+			}
+			$(cur).show();
+			
+			// remove helper and placement box
+			$("#jTreeHelper").empty().hide();
+			
+			$(".jTreePlacement").remove();;
+		};
+
+	}; // end jTree
+
+
+	$.fn.jTree.defaults = {
+		showHelper: false,
+		hOpacity: 0.5,
+		hBg: "#FCC",
+		hColor: "#222",
+		pBorder: "1px dashed #CCC",
+		pBg: "#EEE",
+		pColor: "#222",
+		pHeight: "20px",
+		childOff: 20,
+		snapBack: 1000
+	};
+		  
+})(jQuery);
+
+

data/apps/core/components/widgets/table/table.rb

@@ -28,7 +28,8 @@ module Spider; module Components
         def prepare(action='')
             @model ||= @queryset.model
             if params['sort']
-                @sort = params['sort'].to_sym 
+                @sort_el = params['sort'].keys.first.to_sym 
+                @sort_dir = params['sort'].values.first.to_sym
                 @page = 1
             end
             if (@attributes[:paginate])
@@ -37,16 +38,21 @@ module Spider; module Components
                 @page = @page.to_i
                 @offset = ((@page - 1) * @attributes[:row_limit])
             end
-            if (@sort)
-                if (@model.elements[@sort].model?)
+            @sort_el, @sort_dir = session[:sort] if !@sort_el && session[:sort]
+            session[:sort] = [@sort_el, @sort_dir] if @sort_el
+            @scene.sorted = {}
+            @scene.sorted[@sort_el] = @sort_dir if @sort_el
+            if (@sort_el)
+                if (@model.elements[@sort_el].model?)
                     s = []
-                    @model.elements[@sort].model.each_element{ |el| s << "#{@sort}.#{el.name}" if el.type == String && !el.primary_key? }
-                    @sort = s
+                    element = @model.elements[@sort_el]
+                    @model.elements[@sort_el].model.each_element do |el|                         
+                        s << "#{@sort_el}.#{el.name}" if (el.type == String && !el.primary_key? && element.model.mapper.mapped?(el) )
+                    end
+                    @sort_el = s
                 end
             end
-            @sort = session[:sort] if !@sort && session[:sort]
-            session[:sort] = @sort if @sort
-            @sort = [@sort] if @sort && !@sort.is_a?(Array)
+            @sort_el = [@sort_el] if @sort_el && !@sort_el.is_a?(Array)
             @scene.link_el = @attributes[:link_el]
             @scene.link = @attributes[:link]
             super
@@ -86,7 +92,11 @@ module Spider; module Components
                 @scene.paginate_first = [@page-5, 1].max
                 @scene.paginate = true
             end
-            @rows.order_by(*@sort) if @sort
+            if @sort_el
+                @sort_el.each do |el|
+                    @rows.order_by(el, @sort_dir)
+                end
+            end
             @rows.load
             @scene.rows = prepare_rows(@rows)
             @scene.data = @rows

data/apps/core/components/widgets/table/table.shtml

@@ -7,8 +7,8 @@
     <table sp:if="@rows && @rows.length > 0" class="{ @widget[:css_class] }">
         <thead>
             <tr class="heading_row">
-                <th sp:each="@elements |element|">
-                    <a sp:tag-if="@sortable[element]" href="{ @request[:path] }?_w{ @widget[:param] }[sort]={ element }">
+                <th sp:each="@elements |element|" class="{ (@sorted[element] ? 'sorted-'+@sorted[element].to_s : '') }">
+                    <a sp:tag-if="@sortable[element]" href="{ @request[:path] }?_w{ @widget[:param] }[sort][{ element }]={ @sorted[element] == :asc ? 'desc' : 'asc' }">
                         { @labels[element] }
                     </a>
                 </th>

data/apps/core/forms/widgets/inputs/subform/subform.rb

@@ -0,0 +1,10 @@
+module Spider; module Forms
+    
+    class SubForm < Input
+        tag 'subform'
+        
+        i_attr_accessor :model
+
+    end
+    
+end; end

data/apps/core/forms/widgets/inputs/subform/subform.shtml

@@ -0,0 +1,5 @@
+<div>
+	<div sp:if="!@value && !@shown">
+	Crea nuovo: <input type="checkbox" name="{ @name }[create]" value="true">
+	<forms:form id="form" model="@model" />
+</div>

data/apps/hippo/script/converti_strutture.rb

@@ -0,0 +1,335 @@
+require 'spiderfw'
+require 'optparse' 
+require 'ostruct'
+require 'rexml/document'
+require 'iconv'
+require 'tsort'
+
+
+
+class ConvertiStrutture
+    include TSort
+    
+    def tsort_each_node(&block)
+        @structs.each_key(&block)
+    end
+    
+    def tsort_each_child(node, &block)
+        $stdout << "Doing #{node}\n"
+        return unless @structs[node]
+        return unless @structs[node][:dipendenze]
+        @structs[node][:dipendenze].each(&block)
+    end
+    
+    def self.base_types
+        {
+            'text' => String,
+            'longText' => Spider::DataTypes::Text,
+            'dateTime' => DateTime,
+            'int' => Fixnum,
+            'order' => Fixnum,
+            'bool' => Spider::DataTypes::Bool,
+            'real' => Float,
+            'password' => Spider::DataTypes::Password,
+            'money' => Float,
+            'file' => String,
+            'html' => Spider::DataTypes::Text,
+            'richText' => Spider::DataTypes::Text
+        }
+    end
+    
+    def initialize
+        @ns_mappings = {}
+        @ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
+    end
+    
+    def parse_arguments(args)
+        opts = OptionParser.new 
+        opts.on('-n', '--namespace NS_MAP')    { |val|
+            ns, app = val.split('=')
+            @ns_mappings[ns] = app
+        }            
+        opts.parse!(args)
+        @cartella_destinazione = args.pop.sub(/\/+$/, '') unless args.empty?
+        @applicazione = args.pop
+        list_cartelle_origine = args.pop
+        unless @cartella_destinazione && @applicazione && list_cartelle_origine
+            output_usage
+            exit 0
+        end
+        @cartelle_origine = list_cartelle_origine.split(',')
+        
+    end
+    
+    def output_usage
+        puts "Uso: converti_strutture.rb cartella_origine ModuleDestinazione cartella_destinazione\n\n"
+    end
+    
+    def run
+        @structs = {}
+        @cartelle_origine.each do |cartella_origine|
+            $stderr << "Cartella #{cartella_origine}\n"
+            cartella_origine.sub!(/\/+$/, '')
+            Dir.new(cartella_origine).each do |entry|
+                next if entry[0].chr == '.'
+                next unless entry =~ /\.xml$/
+                $stderr << "Parsing #{cartella_origine+'/'+entry}\n"
+                str = parse_struct(cartella_origine+'/'+entry, File.basename(File.dirname(cartella_origine)))
+                @structs[str[:name]] = str
+            end
+        end
+
+#        res = tsort
+        @structs.each do |name, str|
+            str[:elements].each do |el_name, el|
+                Spider::Logger.debug(el)
+                str[:requires] << struct_file_name(el[:type]) unless el[:type].is_a?(Hash) || self.class.base_types[el[:type]]
+            end
+            if str[:extends]
+                str[:requires] << struct_file_name(str[:extends])
+            end
+            write_struct(str)
+        end
+    end
+    
+    def write_struct(struct)
+        struct[:name] = struct[:name][1..-1] if struct[:name][0].chr == '_'
+        name = struct[:name]
+        if name =~ /(.+)::(.+)$/
+            name = $2
+            ns = $1
+        end
+        model_name = Spider::Inflector.camelize(name)
+
+        code = ""
+        struct[:requires].uniq!
+        Spider::Logger.debug("REQUIRES:")
+        Spider::Logger.debug(struct[:requires])
+        struct[:requires].each do |req|
+            if (req =~ /(.+)\/(.+)/)
+                dest = "#{@cartella_destinazione}/#{$2}"
+            else
+                dest = "apps/hippo/models/#{req}"
+            end
+            code += "require '#{dest}'\n"
+        end
+        code += "\n" if struct[:requires].length > 0
+        code += "module #{@applicazione}\n"
+        superclass = struct[:data] ? 'Spider::Model::InlineModel' : 'Spider::Model::Managed'
+        code += "   class #{model_name} < #{superclass}\n"
+        code += "       include Hippo::HippoStruct\n"
+        if (struct[:extends])
+            code += "       extend_model #{convert_type(struct[:extends])}\n"
+        end
+        code += "\n"
+#        code += "       define_elements do\n"
+        struct[:elements_order].each do |el|
+            next unless struct[:elements][el[:name]]
+            code += write_element(el, "       ")
+        end
+#        code += "       end\n"
+        code += "\n"
+        if struct[:binding]
+            code += "       use_storage 'hippo'\n"
+            code += "       binding (#{struct[:binding].inspect})\n"
+        end
+        code += "       data (#{struct[:data].inspect})\n" if struct[:data]
+        code += "   end\n"
+        code += "end\n"
+        model_name = $1 if (model_name =~ /::(.+)$/)
+        file_name = Spider::Inflector.underscore(model_name)+'.rb'
+        File.open(@cartella_destinazione+'/'+file_name, 'w') do |f|
+            f << code
+        end
+    end
+    
+    def write_element(el, ws)
+        code = ws
+        type = convert_type(el[:type])
+        #type = ":\"#{type}\"" unless el[:type].is_a?(Hash) || self.class.base_types[el[:type]]
+        code += "element :#{convert_element_name(el[:name])}, #{type}"
+        code += ", :required => true" if (el[:required]) 
+        code += ", :multiple => true" if (el[:multiple])
+        code += ", :label => #{el[:label].inspect}" if (el[:label] && !el[:label].empty?)
+        code += ", :add_multiple_reverse => :#{el[:add_multiple_reverse]}" if el[:add_multiple_reverse]
+        code += ", :add_reverse => :#{el[:add_reverse]}" if el[:add_reverse]
+        if (el[:extend]) 
+            code += " do\n"
+            el[:extend].each do |ext|
+                code += write_element(ext, ws+"    ")
+            end
+            code += ws+"end\n"
+        else 
+            code += "\n"
+        end
+        return code
+    end
+    
+    def parse_struct(struct_path, namespace='base')
+        file = File.new(struct_path)
+        xml = REXML::Document.new(file)
+        struct = {
+            :name => namespace+'::'+xml.root.attributes['name'],
+            :elements => {},
+            :elements_order => [],
+            :requires => [],
+            :dipendenze => []
+        }
+        xml.root.elements.each do |el|
+            type = el.attributes['type']
+            case el.name
+            when 'element'
+                el_hash = parse_element(el)
+                struct[:elements][el_hash[:name]] = el_hash
+                struct[:elements_order].push(el_hash)
+                unless type == 'inline' || self.class.base_types[type] || type == struct[:name]
+                    dip_type = el.attributes['type']
+                    found = false
+                    if (@structs[dip_type])
+                        @structs[dip_type][:elements].values.each do |oth_struct_el|
+                            if (oth_struct_el[:type] == struct[:name])
+                                found = oth_struct_el
+                                break
+                            end
+                        end
+                    end
+                    if (found)
+                        if (found[:extend]) # choose theirs
+                            struct[:elements].delete(el_hash[:name])
+                            if (el_hash[:multiple])
+                                found[:add_multiple_reverse] = el_hash[:name]
+                            else
+                                found[:add_reverse] = el_hash[:name]
+                            end
+                        else
+                            @structs[dip_type][:elements].delete(found[:name])
+                            if (found[:multiple])
+                                el_hash[:add_multiple_reverse] = found[:name]
+                            else
+                                el_hash[:add_reverse] = found[:name]
+                            end
+                        end
+                    end
+                end
+            when 'extends'
+                struct[:extends] = el.text
+            when 'extend'
+                element_name = el.attributes['element']
+                struct[:elements][element_name][:extend] = []
+                el.elements.each do |ext_el|
+                    struct[:elements][element_name][:extend] << parse_element(ext_el)
+                end
+            when 'data'
+                h = {}
+                el.elements.each do |row|
+                    k = row.elements[1].text
+                    k = k.to_i if k =~ /^\d+$/
+                    h[k] = @ic.iconv(row.elements[2].text)
+                end
+                struct[:data] = h
+            end
+        end
+        struct[:binding] = parse_binding(struct_path)
+        return struct
+    end
+    
+    def parse_binding(struct_path)
+        struct_name = File.basename(struct_path, 'xml')[0..-2]
+        folder = File.dirname(struct_path)
+        binding_file = folder+'/bindings/'+struct_name+'-db.xml'
+        return nil unless File.exist?(binding_file)
+        f = File.new(binding_file)
+        xml = REXML::Document.new(f)
+        #return nil if xml.root.attributes['autogen']
+        binding = {
+            :table => xml.elements['binding/table'][0].to_s,
+            :elements => {}
+        }
+        xml.elements.each('binding/bind') do |el|
+            el_name = convert_element_name(el.attributes['element'])
+            binding[:elements][el_name] = {:field => el.attributes['dbField']}
+        end
+        xml.elements.each('binding/mmbind') do |el|
+            el_name = convert_element_name(el.attributes['element'])
+            binding[:elements][el_name] = {
+                :type => 'mmbind',
+                :table => el.attributes['table'],
+                :local_id => el.attributes['local_id'],
+                :remote_id => el.attributes['remote_id']
+            }
+        end
+        xml.elements.each('binding/parentRef') do |el|
+            binding[:parent_ref] = {
+                :struct => el.attributes['struct'],
+                :table => el.attributes['table'],
+                :child_id => el.attributes['child_id'],
+                :parent_id => el.attributes['parent_id']
+            }
+        end
+        return binding
+    end
+    
+    
+    
+    def parse_element(xml_element)
+        type = xml_element.attributes['type']
+        if (type == 'inline')
+            h = {}
+            xml_element.elements['data'].elements.each do |row|
+                k = row.elements[1].text
+                k = k.to_i if k =~ /^\d+$/
+                h[k] = row.elements[2].text
+            end
+            type = h
+        end
+        el = {
+            :name => xml_element.attributes['name'],
+            :type => type,
+            :required => xml_element.attributes['required'],
+            :label => @ic.iconv(xml_element.attributes['label']),
+            :multiple => xml_element.attributes['maxOccurs'] ? true : false
+        }
+    end
+    
+    def convert_element_name(name)
+        return Spider::Inflector.underscore(name)
+    end
+    
+    def struct_file_name(struct)
+        struct = struct[1..-1] if struct[0].chr == '_'
+        #struct = $1 if struct =~ /::(.+)$/
+        model_name = Spider::Inflector.camelize(struct)
+        file_name = Spider::Inflector.underscore(model_name)+'.rb'
+    end
+    
+    
+    def convert_type(type)
+        return type.inspect if (type.is_a?(Hash))
+
+        return self.class.base_types[type] if (self.class.base_types[type])
+        return convert_struct_name(type)
+    end
+    
+    def convert_struct_name(struct_name)
+        ns, local = struct_name.split('::')
+        unless local
+            local = ns
+            ns = 'hippo'
+        end
+        local = local[1..-1] if local[0].chr == '_'
+        if @ns_mappings[ns]
+            app = @ns_mappings[ns]
+        else
+            app = Spider::Inflector.camelize(ns)
+        end
+        model_name = Spider::Inflector.camelize(local)
+        return "#{app}::#{model_name}"
+    end
+    
+    
+end
+
+
+conv = ConvertiStrutture.new
+conv.parse_arguments(ARGV)
+conv.run

data/apps/master/_init.rb

@@ -0,0 +1,12 @@
+module Spider
+    module Master
+        include Spider::App
+        @controller = :MasterController
+    end
+end
+
+
+require 'apps/master/models/customer'
+require 'apps/master/models/servant'
+require 'apps/master/controllers/master_controller'
+require 'apps/app_server/app_server'