spiderfw 0.5.7 → 0.5.9

data/lib/spiderfw/model/mixins/state_machine.rb

@@ -4,20 +4,22 @@ module Spider; module Model
 
         def self.included(model)
             model.extend(ClassMethods)
+            model.mapper_include(MapperMethods)
         end
 
         module ClassMethods
+            attr_reader :state_events
 
             class StateEvent
+                attr_reader :transitions
                 
                 def initialize
                     @transitions = []
                     @action = nil
                 end
                 
-                def transitions(params=nil)
+                def transition(params=nil)
                     @transitions << params if params
-                    @transitions
                 end
                 
                 def action(&proc)
@@ -25,6 +27,10 @@ module Spider; module Model
                     @action
                 end
                 
+                def run(obj, old_state, new_state)
+                    @action.call(obj, old_state, new_state)
+                end
+                
             end
 
             def element_association?(name, ass)
@@ -37,45 +43,75 @@ module Spider; module Model
 
             def state(name, type, attributes={}, &proc)
                 attributes[:association] = :state
+                raise "States must be models with one primary key" unless type.is_a?(Hash) || !type.is_a?(Spider::Model::BaseModel) || type.primary_keys.length == 1
                 element(name, type, attributes, &proc)
             end
 
-            def state_event(name)
+            def state_event(element_name)
                 ev = StateEvent.new
                 yield ev
-                @state_events ||= []
-                @state_events << ev
+                @state_events ||= {}
+                @state_events[element_name] ||= []
+                @state_events[element_name] << ev
             end
 
 
         end
         
+        def _pending_state_events
+            @_pending_state_events ||= []
+        end
+        
         module MapperMethods
             
             def before_save(obj, mode)
                 obj.model.elements_array.select{ |el| el.association == :state }.each do |el|
-                    if (obj.model.state_events[el.name] && obj.modified?(el))
+                    if (obj.model.state_events[el.name] && obj.element_modified?(el))
                         old = obj.get_new
                         old_state = old.get(el.name)
                         new_state = obj.get(el.name)
+                        old_state = old_state.primary_keys.first if old_state && el.model?
+                        new_state = new_state.primary_keys.first if new_state && el.model?
                         obj.model.state_events[el.name].each do |event|
                             call_ev = false
                             event.transitions.each do |tr|
-                                if (!tr[:from] || tr[:from] == old_state) && (!tr[:to] || tr[:to] == new_state)
+                                from_ok = false
+                                to_ok = false
+                                if tr[:from]
+                                    tr[:from] = [tr[:from]] unless tr[:from].is_a?(Array)
+                                    from_ok = true if tr[:from].include?(old_state)
+                                else
+                                    from_ok = true
+                                end
+                                if tr[:to]
+                                    tr[:to] = [tr[:to]] unless tr[:to].is_a?(Array)
+                                    to_ok = true if tr[:to].include?(new_state)
+                                else
+                                    to_ok = true
+                                end
+                                if from_ok && to_ok
                                     call_ev = true
                                     break
                                 end
                             end
                             if (call_ev)
-                                event.run(obj)
+                                obj._pending_state_events << [event, old_state, new_state]
                             end
                         end
                     end
                 end
+                super
+            end
+            
+            def after_save(obj, mode)
+                super
+                obj._pending_state_events.each do |event, old_state, new_state|
+                    event.run(obj.get_new, old_state, new_state)
+                end
             end
             
         end
 
     end
 
-end; end
+end; end

data/lib/spiderfw/model/mixins/versioned.rb

@@ -63,7 +63,7 @@ module Spider; module Model
                               junction.versioning(branch)
                           end
                           elh[:attributes][:through] = junction.version_model
-                          elh[:attributes][:junction_our_name] = "#{elh[:attributes][:reverse]}_versioned".to_sym
+                          elh[:attributes][:junction_our_element] = "#{elh[:attributes][:reverse]}_versioned".to_sym
                           elh[:attributes][:junction_their_element] = "#{elh[:attributes][:junction_their_element]}_versioned".to_sym
                           vname = "#{elh[:name]}_versioned".to_sym
                           vmod.send(elh[:method], vname, el.type.version_model, elh[:attributes])

data/lib/spiderfw/model/model.rb

@@ -34,7 +34,8 @@ module Spider
             map_types = {
                 Spider::DataTypes::Text => String,
                 Spider::DataTypes::Bool => FalseClass,
-                Spider::DataTypes::Binary => String
+                Spider::DataTypes::Binary => String,
+                Spider::DataTypes::FilePath => String
             }
             return map_types[klass] if map_types[klass]
             return klass

data/lib/spiderfw/model/query_set.rb

@@ -326,6 +326,12 @@ module Spider; module Model
             end
         end
         
+        # Remove all elements from self
+        def clear
+            @objects = []
+            @index_lookup.each_key{ |k| @index_lookup[k] = {} }
+        end
+        
         # Remove when merging
         alias :map_array :map
         
@@ -336,13 +342,22 @@ module Spider; module Model
 
         # Iterates on objects, loading when needed.
         def each
+            tmp = []
+            prev_parents = []
             self.each_index do |i|
                 obj = @objects[i]
                 prev_parent = obj._parent
                 prev_parent_element = obj._parent_element
                 obj.set_parent(self, nil)
+                tmp << obj
+                prev_parents << [prev_parent, prev_parent_element]
+            end
+            tmp.each do |obj|
                 yield obj
-                obj.set_parent(prev_parent, prev_parent_element)
+            end
+            tmp.each_index do |i|
+                prev_parent, prev_parent_element = prev_parents[i]
+                tmp[i].set_parent(prev_parent, prev_parent_element)
             end
         end
 
@@ -406,8 +421,7 @@ module Spider; module Model
         # Executes the query and fetches the objects; (the next batch if a fetch_window is set).
         def load
             return self unless loadable?
-            @objects = []
-            @index_lookup.each_key{ |k| @index_lookup[k] = {} }
+            clear
             @loaded = false
             @loaded_elements = {}
             return load_next if @fetch_window && !@query.offset
@@ -599,6 +613,10 @@ module Spider; module Model
                 h
             end
         end
+
+        def reject!(&proc)
+            @objects.reject!(&proc)
+        end
         
         def to_s
             self.map{ |o| o.to_s }.join(', ')

data/lib/spiderfw/model/request.rb

@@ -10,6 +10,8 @@ module Spider; module Model
         attr_accessor :total_rows
         # (array) find also the given subclasses of the queried model.
         attr_reader :polymorphs
+        # (bool) if true, the request will be expanded with lazy groups on load
+        attr_accessor :expandable
         
         def initialize(val=nil, params={})
             if (val.is_a?(Array))
@@ -20,6 +22,7 @@ module Spider; module Model
             end
             @total_rows = params[:total_rows]
             @polymorphs = {}
+            @expandable = true
         end
         
         # TODO: fix/remove?
@@ -73,6 +76,10 @@ module Spider; module Model
         def with_superclass?
             @with_superclass
         end
+        
+        def expandable?
+            @expandable
+        end
     
     end
 

data/lib/spiderfw/model/storage/db/adapters/mssql.rb

@@ -11,7 +11,8 @@ module Spider; module Model; module Storage; module Db
             {
                 :autoincrement => true,
                 :sequences => false,
-                :transactions => true
+                :transactions => true,
+                :foreign_keys => false # not implemented
             }
         end
         

data/lib/spiderfw/model/storage/db/adapters/mysql.rb

@@ -12,7 +12,8 @@ module Spider; module Model; module Storage; module Db
         @capabilities = {
             :autoincrement => true,
             :sequences => false,
-            :transactions => true
+            :transactions => true,
+            :foreign_keys => true
         }
         @reserved_keywords = superclass.reserved_keywords
         @safe_conversions = {
@@ -228,6 +229,8 @@ module Spider; module Model; module Storage; module Db
              value = super(type, value)
              return value unless value
              case type.name
+             when 'String'
+                 return value.to_s
              when 'Date', 'DateTime'
                  return value.strftime("%Y-%m-%dT%H:%M:%S")
              when 'Fixnum'

data/lib/spiderfw/model/storage/db/adapters/oci8.rb

@@ -7,9 +7,10 @@ module Spider; module Model; module Storage; module Db
         @capabilities = {
             :autoincrement => false,
             :sequences => true,
-            :transactions => true
+            :transactions => true,
+            :foreign_keys => true
         }
-        @reserved_keywords = superclass.reserved_keywords + ['oci8_row_num', 'file', 'uid']
+        @reserved_keywords = superclass.reserved_keywords + ['oci8_row_num', 'file', 'uid', 'name', 'comment']
         @safe_conversions = {
             'CHAR' => ['VARCHAR', 'CLOB'],
             'VARCHAR' => ['CLOB'],
@@ -24,6 +25,7 @@ module Spider; module Model; module Storage; module Db
         def self.new_connection(user, pass, dbname, role)
             conn ||= ::OCI8.new(user, pass, dbname, role)
             conn.autocommit = true
+            conn.non_blocking = true
             return conn
         end
         
@@ -69,19 +71,23 @@ module Spider; module Model; module Storage; module Db
         
 
         def do_start_transaction
+            return unless transactions_enabled?
             connection.autocommit = false
         end
         
         def in_transaction?
+            return false unless transactions_enabled?
             return curr[:conn] && !curr[:conn].autocommit?
         end
         
         def do_commit
+            return release unless transactions_enabled?
             curr[:conn].commit if curr[:conn]
             release
         end
         
         def do_rollback
+            return release unless transactions_enabled?
             curr[:conn].rollback
             release
         end
@@ -108,7 +114,7 @@ module Spider; module Model; module Storage; module Db
             case type.name
             when 'Date', 'DateTime'
                 return nil unless value
-                return value if value.is_a?(Type)
+                return value if value.is_a?(type)
                 return value.to_datetime if type == DateTime
                 return value.to_date # FIXME: check what is returned, here we espect an OCI8::Date
             when 'Spider::DataTypes::Text'
@@ -126,15 +132,15 @@ module Spider; module Model; module Storage; module Db
                  end
                  curr[:last_executed] = [sql, bind_vars]
                  if (Spider.conf.get('storage.db.replace_debug_vars'))
-                     cnt = -1
-                     debug("oci8 executing: "+sql.gsub(/:\d+/){
-                         v = bind_vars[cnt]
-                         dv = debug_vars[cnt+=1]
+                     debug("oci8 #{connection} executing: "+sql.gsub(/:(\d+)/){
+                         i = $1.to_i
+                         v = bind_vars[i-1]
+                         dv = debug_vars[i-1]
                          v.is_a?(String) ? "'#{dv}'" : dv
                      })
                  else
                      debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
-                     debug("oci8 executing:\n#{sql}\n[#{debug_vars_str}]")
+                     debug("oci8 #{connection} executing:\n#{sql}\n[#{debug_vars_str}]")
                  end
                  cursor = connection.parse(sql)
                  return cursor if (!cursor || cursor.is_a?(Fixnum))
@@ -152,11 +158,16 @@ module Spider; module Model; module Storage; module Db
                  if (have_result)
                      result = []
                      while (h = cursor.fetch_hash)
+                         h.each do |key, val|
+                             if val.respond_to?(:read)
+                                 h[key] = val.read
+                             end
+                         end
                          if block_given?
-                              yield h
-                          else
-                              result << h
-                          end
+                             yield h
+                         else
+                             result << h
+                         end
                      end
                  end
                  if (have_result)
@@ -168,9 +179,14 @@ module Spider; module Model; module Storage; module Db
                  else
                      return res
                  end
+                 cursor.close
+
              rescue => exc
+                 curr[:conn].break if curr[:conn]
+                 rollback! if in_transaction?
+                 #curr[:conn].logoff
                  release
-                 raise exc
+                 raise
              ensure
                  cursor.close if cursor
                  release if curr[:conn] && !in_transaction?
@@ -234,6 +250,7 @@ module Spider; module Model; module Storage; module Db
              # Spider::Logger.debug("SQL SELECT:")
              # Spider::Logger.debug(query)
              bind_vars = query[:bind_vars] || []
+             order_on_different_table = false
              if query[:limit] # Oracle is so braindead
                  replaced_fields = {}
                  replace_cnt = 0
@@ -248,6 +265,7 @@ module Spider; module Model; module Storage; module Db
                      #   end
                      transformed = "O#{replace_cnt += 1}"
                      replaced_fields[field.to_s] = transformed
+                     order_on_different_table = true if field.is_a?(Spider::Model::Storage::Db::Field) && !query[:tables].include?(field.table)
                      if (field.is_a?(Spider::Model::Storage::Db::Field) && field.type == 'CLOB')
                          field = "CAST(#{field} as varchar2(100))"
                      end
@@ -262,7 +280,7 @@ module Spider; module Model; module Storage; module Db
              where, vals = sql_condition(query)
              bind_vars += vals
              sql += "WHERE #{where} " if where && !where.empty?
-             order = sql_order(query)
+             order = sql_order(query, replaced_fields)
              if (query[:limit])
                  if (query[:offset])
                      limit = "oci8_row_num between :#{curr[:bind_cnt]+=1} and :#{curr[:bind_cnt]+=1}"
@@ -272,14 +290,12 @@ module Spider; module Model; module Storage; module Db
                      limit = "oci8_row_num < :#{curr[:bind_cnt]+=1}"
                      bind_vars << query[:limit] + 1
                  end
-                 replaced_fields.each do |f, repl|
-                     order = order.gsub(f, repl)
-                 end
                  if (!query[:joins].empty?)
+                     data_tables_sql = order_on_different_table ? tables_sql : query[:tables].join(', ')
                      pk_sql = query[:primary_keys].join(', ')
                      distinct_sql = "SELECT DISTINCT #{pk_sql} FROM #{tables_sql}"
                      distinct_sql += " WHERE #{where}" if where && !where.empty?
-                     data_sql = "SELECT #{keys} FROM #{tables_sql} WHERE #{pk_sql} IN (#{distinct_sql}) order by #{order}"
+                     data_sql = "SELECT #{keys} FROM #{data_tables_sql} WHERE (#{pk_sql}) IN (#{distinct_sql}) order by #{order}"
                  else
                      data_sql = "#{sql} order by #{order}"
                  end
@@ -296,6 +312,7 @@ module Spider; module Model; module Storage; module Db
          end
          
          def sql_condition_value(key, comp, value, bound_vars=true)
+             curr[:bind_cnt] ||= 0
              if (comp.to_s.downcase == 'ilike')
                  comp = 'like'
                  key = "UPPER(#{key})"

data/lib/spiderfw/model/storage/db/adapters/sqlite.rb

@@ -6,30 +6,39 @@ module Spider; module Model; module Storage; module Db
     class SQLite < DbStorage
         @reserved_keywords = superclass.reserved_keywords + []
         @capabilities = {
-            :autoincrement => false,
+            :autoincrement => true,
             :sequences => true,
-            :transactions => true
+            :transactions => true,
+            :foreign_keys => false
         }
 
         class << self; attr_reader :reserved_kewords; end
         
+        def self.max_connections
+            1
+        end
+        
         def self.base_types
             super << Spider::DataTypes::Binary
         end
         
         def self.new_connection(file)
-            @db = SQLite3::Database.new(file)
-            @db.results_as_hash = true
-            return @db
+            db = SQLite3::Database.new(file)
+            db.results_as_hash = true
+            return db
         end
         
-        def connect
-            @conn = self.class.new_connection(*@connection_params) unless @conn
+        def self.connection_alive?(conn)
+            !conn.closed?
         end
         
         def release
-            @conn.close if @conn
-            @conn = nil
+            begin
+                #curr[:conn].close
+                super
+            rescue
+                curr[:conn] = nil
+            end
         end
         
         
@@ -43,26 +52,30 @@ module Spider; module Model; module Storage; module Db
             @connection_params = [@file]
         end
         
-        def start_transaction
+        def do_start_transaction
+            return unless transactions_enabled?
             connection.transaction
         end
         
         def in_transaction?
-            @conn && @conn.transaction_active?
+            return false unless transactions_enabled?
+            return curr[:conn] && curr[:conn].transaction_active?
         end
         
-        def commit
-            @conn.commit
+        def do_commit
+            return release unless transactions_enabled?
+            curr[:conn].commit if curr[:conn]
             release
         end
-        
-        def rollback
-            @conn.rollback
+                
+        def do_rollback
+            return release unless transactions_enabled?
+            curr[:conn].rollback
             release
         end
-        
+                
         def assigned_key(key)
-            @last_insert_row_id
+            curr[:last_insert_row_id]
         end
         
         def value_for_save(type, value, save_mode)
@@ -81,9 +94,9 @@ module Spider; module Model; module Storage; module Db
                  debug("sqlite executing:\n#{sql}\n[#{debug_vars}]")
 
                  result = connection.execute(sql, *bind_vars)
-                 @last_insert_row_id = connection.last_insert_row_id
+                 curr[:last_insert_row_id] = connection.last_insert_row_id
                  result.extend(StorageResult)
-                 @last_result = result
+                 curr[:last_result] = result
                  if block_given?
                      result.each{ |row| yield row }
                  else
@@ -97,8 +110,7 @@ module Spider; module Model; module Storage; module Db
 
          def prepare(sql)
              debug("sqlite preparing: #{sql}")
-             connect unless connected?
-             return @conn.prepare(sql)
+             return connection.prepare(sql)
          end
 
          def execute_statement(stmt, *bind_vars)
@@ -106,10 +118,10 @@ module Spider; module Model; module Storage; module Db
          end
          
          def total_rows
-             return nil unless @last_query
-             q = @last_query
+             return nil unless curr[:last_query]
+             q = curr[:last_query]
              unless (q[:offset] || q[:limit])
-                 return @last_result ? @last_result.length : nil
+                 return curr[:last_result] ? curr[:last_result].length : nil
              end
              q[:offset] = q[:limit] = nil
              q[:keys] = ["COUNT(*) AS N"]
@@ -117,6 +129,10 @@ module Spider; module Model; module Storage; module Db
              return res[0]['N']
          end
          
+         #############################################################
+         #   SQL methods                                             #
+         #############################################################
+         
          ##############################################################
          #   Methods to get information from the db                   #
          ##############################################################
@@ -127,17 +143,35 @@ module Spider; module Model; module Storage; module Db
 
          def describe_table(table)
              columns = {}
-             stmt = prepare("select * from #{table}")
-             stmt.columns.each_index do |index|
-                 field = stmt.columns[index]
-                 columns[field] ||= {}
-                 if (stmt.types[index] =~ /([^\(]+)(?:\((\d+)\))?/)
-                     columns[field][:type] = $1
-                     columns[field][:length] = $2.to_i if $2
+             primary_keys = []
+             res = execute("PRAGMA table_info('#{table}')")
+             res.each do |row|
+                 name = row['name']
+                 type = row['type']
+                 length = nil
+                 precision = nil
+                 if type =~ /(.+)\((.+)\)/
+                     type = $1
+                     length = $2
+                 end
+                 if length && length.include?(",")
+                     length, precision = length.split(',')
                  end
+                 length = length.to_i if length
+                 precision = precision.to_i if length
+                 primary_keys << name if row['pk'] == "1"
+                 columns[name] = {:type => type, :length => length, :precision => precision}
              end
-             stmt.close
-             return {:columns => columns}
+             # stmt.columns.each_index do |index|
+             #     field = stmt.columns[index]
+             #     columns[field] ||= {}
+             #     if (stmt.types[index] =~ /([^\(]+)(?:\((\d+)\))?/)
+             #         columns[field][:type] = $1
+             #         columns[field][:length] = $2.to_i if $2
+             #     end
+             # end
+             # stmt.close
+             return {:columns => columns, :primary_keys => primary_keys}
          end
 
          def table_exists?(table)

data/lib/spiderfw/model/storage/db/connectors/odbc.rb

@@ -37,7 +37,7 @@ module Spider; module Model; module Storage; module Db; module Connectors
         end
         
         def parse_url(url)
-            # adapter//<username:password>@<dsn>
+            # adapter://<username:password>@<dsn>
             if (url =~ /(.+):\/\/(?:(.+):(.+)@)?(.+)/)
                 @adapter = $1
                 @user = $2