spiderfw 0.5

data/lib/spiderfw/model/storage/db/dialects/no_total_rows.rb

@@ -0,0 +1,18 @@
+module Spider; module Model; module Storage; module Db; module Dialects
+    
+    module NoTotalRows
+        
+        def total_rows
+            return nil unless @last_executed
+            q = @last_query.clone
+            unless (q[:offset] || q[:limit])
+                return @last_result ? @last_result.length : nil
+            end
+            q.delete(:offset); q.delete(:limit); q[:order]= []
+            q[:query_type] = :count
+            return query(q)
+        end
+        
+    end
+    
+end; end; end; end; end

data/lib/spiderfw/model/storage/db/reflector.rb

@@ -0,0 +1,36 @@
+module Spider; module Model; module Storage; module Db
+    
+    class Reflector
+       
+       def reflect_table(storage, table_name, target)
+           mod = Class.new(Spider::Model::BaseModel)
+           model_name = table_to_model_name(table_name)
+           target.const_set(model_name, mod)
+           table = storage.describe_table(table_name)
+           table[:columns].each do |column_name, column|
+               name, type, attributes = field_to_element(table_name, column_name, column, storage)
+               mod.element(name, type, attributes)
+           end
+           mod.attributes[:db_table]  = table_name
+           return mod
+       end
+       
+       def table_to_model_name(table_name)
+           model_name = Spider::Inflector.camelize(table_name)
+       end
+       
+       def column_to_element_name(column_name)
+           name = Inflector.underscore(column_name)
+       end
+       
+       def field_to_element(table_name, column_name, column_details, storage)
+           type, attributes = storage.reflect_column(table_name, column_name, column_details)
+           attributes[:primary_key] = true if (column_details[:primary_key])
+           attributes[:db_column_name] = column_name
+           return column_to_element_name(column_name), type, attributes
+       end
+        
+    end
+    
+    
+end; end; end; end

data/lib/spiderfw/model/storage/null_storage.rb

@@ -0,0 +1,18 @@
+require 'spiderfw/model/storage/base_storage'
+
+module Spider; module Model; module Storage
+
+    class NullStorage
+
+        def get_mapper(model)
+            require 'spiderfw/model/mappers/null_mapper'
+            mapper = Spider::Model::Mappers::NullMapper.new(model, self)
+            return mapper
+        end
+
+        def parse_url(url)
+        end
+
+    end
+
+end; end; end

data/lib/spiderfw/model/storage/schema.rb

@@ -0,0 +1,19 @@
+module Spider; module Model; module Storage
+
+    class Schema
+         
+         def initialize()
+         end
+         
+         
+         
+    end
+    
+    #############################
+    #   Exceptions              #
+    #############################
+    
+    class SchemaException < RuntimeError
+    end
+    
+end; end; end

data/lib/spiderfw/model/storage.rb

@@ -0,0 +1,72 @@
+#require 'spiderfw/model/storage/db/connectors/odbc'
+
+module Spider; module Model
+    
+    module Storage
+        
+        
+        def self.get_storage(type, url)
+            Thread.current[:storages] ||= {}
+            Thread.current[:storages][type] ||= {}
+            return Thread.current[:storages][type][url] if Thread.current[:storages][type][url]
+            case type
+            when 'db'
+                matches = url.match(/^(.+?):\/\/(.+)/)
+                adapter = matches[1]
+                rest = matches[2]
+                if (adapter =~ /(.+):(.+)/)
+                    connector = $1
+                    adapter = $2
+                    url = "#{adapter}://#{rest}"
+                end
+                case adapter
+                when 'sqlite'
+                    class_name = :SQLite
+                when 'oci8'
+                    class_name = :OCI8
+                when 'mysql'
+                    class_name = :Mysql
+                when 'mssql'
+                    class_name = :MSSQL
+                end
+                klass = Db.const_get(class_name)
+                if (connector)
+                    case connector
+                    when 'odbc'
+                        conn_mod = :ODBC
+                    end
+                    conn_class = "#{conn_mod}#{class_name}"
+                    if Db.const_defined?(conn_class)
+                        klass = Db.const_get(conn_class)
+                    else
+                        klass = Db.const_set(conn_class, Class.new(klass))
+                        klass.instance_eval{ include Db::Connectors.const_get(conn_mod)}
+                    end
+                end
+                Thread.current[:storages][type][url] = klass.new(url)
+                return Thread.current[:storages][type][url]
+            end
+        end
+        
+        module StorageResult
+            attr_accessor :total_rows
+            
+        end
+        
+        class StorageException < RuntimeError
+        end
+        
+        class DuplicateKey < StorageException
+        end
+        
+        ###############################
+        #   Autoload                  #
+        ###############################
+        
+        Storage.autoload(:Db, 'spiderfw/model/storage/db/db')
+                
+    end
+    
+end; end
+
+require 'spiderfw/model/storage/db/db'

data/lib/spiderfw/model/sync.rb

@@ -0,0 +1,94 @@
+require 'tsort'
+
+module Spider; module Model
+    
+    class Sync
+        include TSort
+        
+        def initialize
+            @model_tasks = {}
+            @processed_deps = {}
+            @processed = {}
+        end
+        
+        def add(model)
+            collect_dependencies(model)
+        end
+        
+        def each
+            tasks = tsort
+            pp tasks
+            tasks.each do |task|
+                yield task.model
+            end
+        end
+        
+        def length
+          @model_tasks.keys.length
+        end
+        
+        # def dump(model, model_server)
+        #     collect_dependencies(model)
+        #     tasks = tsort
+        # end
+        # 
+        # def fetch!(model, model_server)
+        #     model.mapper.delete_all!
+        #     collect_dependencies(model)
+        #     tasks = tsort
+        #     tasks.each do |task|
+        #         res = model_server.all(model.name)
+        #         res.each do |obj|
+        #             debugger
+        #             model.mapper.insert(obj)
+        #         end
+        #     end
+        # end
+        
+        def tsort_each_node(&block)
+            @model_tasks.each_value(&block)
+        end
+        
+        def tsort_each_child(node, &block)
+            node.dependencies.each(&block)
+        end
+        
+        def collect_dependencies(model)
+            return collect_dependencies(model.superclass) if model.attributes[:inherit_storage]
+            return if model.subclass_of?(Spider::Model::InlineModel)
+            @processed_deps[model] = true
+            @model_tasks[model] ||= SyncTask.new(model)
+            model.elements_array.select{ |el| el.model? && model.mapper.have_references?(el) }.each do |el|
+                @model_tasks[el.model] ||= SyncTask.new(el.model)
+                @model_tasks[model] << @model_tasks[el.model]
+            end
+            model.elements_array.select{ |el| el.model? }.each do |el|
+                collect_dependencies(el.model) unless @processed_deps[el.model]
+            end
+        end
+        
+        class SyncTask
+            attr_reader :model, :dependencies
+            
+            def initialize(model)
+                @model = model
+                @dependencies = []
+            end
+            
+            def <<(model)
+                @dependencies << model
+            end
+            
+            def eql?(other)
+                @model == other.model
+            end
+            
+            def inspect
+                "#{@model.name} -> (#{dependencies.map{|d| d.model.name }.join(', ')})"
+            end
+                
+        end
+        
+    end
+    
+end; end

data/lib/spiderfw/model/type.rb

@@ -0,0 +1,13 @@
+module Spider; module Model
+    
+    class Type
+        @maps_to = 'string'
+        
+        def self.maps_to
+            @maps_to
+        end
+        
+    end
+    
+    
+end; end

data/lib/spiderfw/model/unit_of_work.rb

@@ -0,0 +1,75 @@
+require 'tsort'
+
+module Spider; module Model
+    
+    class UnitOfWork
+        include TSort
+        
+        def initialize(&proc)
+            @objects = {}
+            if (proc)
+                Thread.current[:unit_of_work] = self
+                yield self
+                Thread.current[:unit_of_work] = nil
+            end
+        end
+        
+        def run() #(&proc)
+            #proc.call
+            @tasks = {}
+            @processed_tasks = {}
+            @objects.each do |obj_id, obj|
+                next unless obj.mapper && obj.mapper.class.write?
+                task = Spider::Model::MapperTask.new(obj, :save)
+                @tasks[task] ||= task
+                find_dependencies(task)
+            end
+            tasks = tsort()
+            tasks.each{ |task| p task}
+            tasks.each do |task|
+                Spider::Logger.debug("Executing task #{task.inspect}")
+                task.execute()
+            end
+        end
+        
+        def find_dependencies(model_task)
+            return if (@processed_tasks[model_task])
+            @processed_tasks[model_task] = true
+            dependencies = model_task.object.mapper.get_dependencies(model_task.object, model_task.action)
+            dependencies.each do |dep|
+                @tasks[dep[0]] ||= dep[0]
+                @tasks[dep[1]] ||= dep[1]
+                @tasks[dep[0]] << @tasks[dep[1]]
+                find_dependencies(dep[1])
+            end
+        end
+                
+        
+        def add(obj)
+            if (obj.class == QuerySet)
+                obj.each do |item|
+                    @objects[item.object_id] = item
+                end
+            else
+                @objects[obj.object_id] = obj
+            end
+        end
+        
+        
+        def tsort_each_node(&block)
+            @tasks.values.each(&block)
+        end
+        
+        def tsort_each_child(node, &block)
+            node.dependencies.each(&block)
+        end
+        
+        
+        
+    end
+
+    
+
+    
+    
+end; end

data/lib/spiderfw/requires.rb

@@ -0,0 +1,21 @@
+require 'spiderfw/i18n/gettext'
+require 'spiderfw/i18n/i18n'
+require 'spiderfw/exceptions'
+require 'spiderfw/utils/monkey/kernel'
+require 'spiderfw/utils/monkey/module'
+require 'spiderfw/utils/monkey/class'
+require 'spiderfw/utils/monkey/symbol'
+require 'spiderfw/utils/monkey/time'
+require 'spiderfw/utils/monkey/date_time'
+require 'spiderfw/utils/monkey/exception'
+require 'spiderfw/utils/multi_level_hash'
+require 'spiderfw/utils/thread_out'
+require 'spiderfw/utils/inflector'
+require 'spiderfw/utils/periodic_runner'
+require 'spiderfw/utils/fork'
+require 'spiderfw/config/configuration'
+require 'spiderfw/config/configurable'
+require 'spiderfw/model/model'
+require 'spiderfw/home'
+require 'spiderfw/resource'
+

data/lib/spiderfw/resource.rb

@@ -0,0 +1,18 @@
+module Spider
+    
+    class Resource
+        attr_reader :path
+        attr_reader :definer
+        
+        def initialize(path, definer=nil)
+            @path = path
+            @definer = definer
+        end
+        
+        def to_s
+            @path
+        end
+        
+    end
+    
+end

data/lib/spiderfw/setup/setup_task.rb

@@ -0,0 +1,44 @@
+module Spider
+    
+    class SetupTask
+        attr_reader :path, :version
+        
+        class <<self
+            def tasks
+                @tasks ||= {}
+            end
+            
+            def inherited(subclass)
+                @last_class = subclass
+            end
+            
+            def load(path)
+                crit = Thread.critical
+                Thread.critical = true unless crit
+                Kernel.load(path)
+                obj = @last_class.new(path)
+#                Kernel.send(:remove_const, @last_class.name)
+                @last_class = nil
+                Thread.critical = crit
+                return obj
+            end
+        end
+        
+        def initialize(path)
+            @path = path
+            name = File.basename(path, '.rb')
+            if (name =~ /^((?:\d\.?){1,3})/)
+                version = $1
+                version = version[0..-2] if version[-1].chr == '.'
+                desc = name[(version.length+1)..-1]
+            else
+                version = name
+                desc = nil
+            end
+            @version = Gem::Version.new(version)
+            @desc = desc
+        end
+
+    end
+    
+end

data/lib/spiderfw/tag/tag.rb

@@ -0,0 +1,28 @@
+require 'erb'
+
+module Spider
+    
+    class Tag
+        
+        class << self
+            attr_accessor :path
+            
+            def new_class(path)
+                k = Class.new(self)
+                k.path = path
+                return k
+            end
+        end
+        
+        def initialize(el)
+            @attributes = el.attributes
+            @content = el.innerHTML
+        end
+        
+        def render
+            return ERB.new(IO.read(self.class.path)).result(binding)
+        end
+        
+    end
+    
+end

data/lib/spiderfw/templates/blocks/attr_if.rb

@@ -0,0 +1,32 @@
+require 'spiderfw/templates/template_blocks'
+
+module Spider; module TemplateBlocks
+    
+    # *sp:attr-if*
+    # Adds an attribute if a condition holds
+    # Example:
+    #   <div sp:attr-if="@my_condition,class,coolDiv"></div>
+    
+    class AttrIf < Block
+        
+        def compile(options={})
+            init = ""
+            attr_if = @el.attributes['sp:attr-if']
+            @el.remove_attribute('sp:attr-if')
+            @el.set_attribute("tmp-attr-if", attr_if)
+            compiled = Spider::TemplateBlocks.parse_element(@el, @allowed_blocks, @template).compile(options)
+            c, init = compiled.run_code, compiled.init_code
+            cond, name, val = attr_if.split(',')
+            cond = vars_to_scene(cond)
+            full_attr = val ? "#{name}=\"#{val}\"" : "#{name}"
+            replace = "'+"+"( (#{cond}) ? '#{full_attr}' : '' )"+"+'"
+#            debug("ATTR IF REPLACe")
+            c.sub!('tmp-attr-if="'+attr_if+'"', replace)
+            return CompiledBlock.new(init, c)
+        end
+        
+        
+    end
+    
+    
+end; end

data/lib/spiderfw/templates/blocks/comment.rb

@@ -0,0 +1,38 @@
+require 'spiderfw/templates/template_blocks'
+
+module Spider; module TemplateBlocks
+    
+    class Comment < Block
+        
+        def compile(options={})
+            init = nil
+            c = ""
+            str = nil
+            mode = nil
+            if (@el.content[0].chr == '-')
+                mode = :internal
+            elsif (@el.content[0].chr == '+')
+                mode = :parse
+            else
+                mode = :verbatim
+            end
+            if (mode == :parse)
+                str = ""
+                rest = scan_vars(@el.to_s) do |text, code|
+                    str += escape_text(text)+"'+("+vars_to_scene(code)+").to_s+'"
+                end
+                str += escape_text(rest)
+            elsif (mode == :verbatim)
+                str = escape_text(@el.to_s)
+            else
+                str = nil
+            end
+            c += "$out << '#{str}'\n" if str
+            #c += "$out << '#{@el.to_s}'\n"
+            return CompiledBlock.new(init, c)
+        end
+
+    end
+    
+    
+end; end

data/lib/spiderfw/templates/blocks/debugger.rb

@@ -0,0 +1,16 @@
+require 'spiderfw/templates/template_blocks'
+
+module Spider; module TemplateBlocks
+    
+    class Debugger < Block
+        
+        def compile(options={})
+            c = "debugger\n"
+            init = nil
+            return CompiledBlock.new(init, c)
+        end
+        
+    end
+    
+    
+end; end

data/lib/spiderfw/templates/blocks/each.rb

@@ -0,0 +1,51 @@
+require 'spiderfw/templates/template_blocks'
+
+module Spider; module TemplateBlocks
+    
+    class Each < Block
+        
+        def initialize(el, template=nil, allowed_blocks=nil)
+            @repeated = []
+            super
+        end
+        
+        def compile(options={})
+            init = ""
+            rep_type = nil
+            rep = nil
+            ['sp:each', 'sp:each_index'].each do |name|
+                if (@el.attributes[name])
+                    rep_type = name[3..-1]
+                    rep = @el.attributes[name]
+                    @el.remove_attribute(name)
+                    break
+                end
+            end
+            return nil unless rep_type
+            if (rep =~ /\s*(.+)\s*\|\s*(.+)\s*\|/)
+                repeated = $1.strip
+                arguments = $2.strip
+            end
+            c = "#{vars_to_scene(repeated)}.#{rep_type} do |#{arguments}|\n"
+            content = Spider::TemplateBlocks.parse_element(@el, @allowed_blocks, @template).compile(options)
+            content.run_code.each_line do |line|
+                c += '  '+line
+            end
+            c += '   $out << "\n"'
+            c += "\n"
+            c += "end\n"
+            init += content.init_code if content.init_code
+            return CompiledBlock.new(init, c)
+        end
+        
+        def get_following(el)
+            return false if (el.class == ::Hpricot::Text)
+            if (el.name == 'sp:repeated')
+                @repeated << el
+            end
+        end
+        
+    end
+    
+    
+end; end

data/lib/spiderfw/templates/blocks/html.rb

@@ -0,0 +1,70 @@
+require 'spiderfw/templates/template_blocks'
+
+module Spider; module TemplateBlocks
+    
+    class HTML < Block
+        
+        def compile(options={})
+            c = ""
+            init = ""
+            start = get_start(options)
+            c += "$out << '#{start}'\n"
+            is_root = options[:root]
+            options.delete(:root)
+            c += "unless self[:widget][:target_only] && !self[:widget][:is_target]\n" if (options[:mode] == :widget && is_root)
+            c, init = compile_content(c, init, options)
+            c += "end\n"  if (options[:mode] == :widget && is_root)
+            end_tag = get_end
+            c += "$out << '#{end_tag}'\n" if end_tag
+            return CompiledBlock.new(init, c)
+        end
+        
+        def get_start(options)
+            if options[:mode] == :widget
+                cl = @el.attributes['class'] || ''
+                if @el.attributes['id']
+                    cl += ' ' unless cl.empty?
+                    cl += "id-#{@el.attributes['id']}"
+                    @el.raw_attributes.delete('id')
+                end
+                if (options[:root])
+                    cl += " widget"
+                    if options[:owner_class]
+                        cl += " wdgt-#{options[:owner_class].name.gsub('::', '-')}"
+                    end
+                    @el.raw_attributes['id'] =  "{ @widget[:full_id] }"
+                    cl += ' ' unless cl.empty?
+                    cl += '{ @widget[:css_classes] }'
+                end
+                @el.raw_attributes['class'] = cl
+            end
+            start = "<"+@el.name
+            @el.attributes.each do |key, val|
+                start += " #{key}=\""
+                rest = scan_vars(val) do |text, code|
+                    start += text+"'+("+vars_to_scene(code)+").to_s+'"
+                end
+                start += rest
+#                start += replace_vars(val)
+                # if (val =~ /(.*)\{ (.+) \}(.*)/)
+                #     start += $1+"'+"+var_to_scene($2)+".to_s+'"+$3
+                # else
+                #     start += val
+                # end
+                start += '"'
+            end
+            #start += " /" unless @el.etag
+            start += ">"
+            return start
+        end
+        
+        def get_end
+            str = escape_text(@el.etag.inspect) if @el.etag
+            str = str[1..-2] if str && str[0].chr == '"' # FIXME:  This is a workaround Hpricot 0.6 and 0.8 differences
+            return str
+        end
+        
+    end
+    
+    
+end; end