spiderfw 0.5.13 → 0.5.14

data/apps/hippo/script/converti_strutture.rb

@@ -1,335 +0,0 @@
-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/lib/spiderfw/utils/setup_task.rb

@@ -1,35 +0,0 @@
-module Spider
-    
-    # TODO: remove?
-    class SetupTask #:nodoc:
-        
-        # FIXME: concurrency?
-        def self.current_task=(task)
-            @current_task = task
-        end
-        
-        def self.current_task
-            @current_task
-        end
-        
-        def self.inherited(subclass)
-            Spider::SetupTask.current_task = subclass
-        end
-        
-        def run
-        end
-        
-        def rollback
-            raise SetupError, "Rollback not implemented for SetupTask #{self.class}"
-        end
-        
-        def done
-            Spider::SetupTask.current_task = nil
-        end
-        
-    end
-    
-    class SetupError < RuntimeError
-    end
-    
-end

data/lib/spiderfw/utils/test_case.rb

@@ -1,24 +0,0 @@
-require 'test/unit'
-
-module Spider
-   
-   class TestCase < Test::Unit::TestCase
-       
-       def self.standalone
-           @standalone
-       end
-       
-       def setup
-          Spider._test_setup if self.class.standalone 
-       end
-       
-       def teardown
-           Spider._test_teardown if self.class.standalone
-       end
-       
-       def test_dummy
-       end
-       
-   end
-    
-end