spiderfw 0.5.13 → 0.5.14

data/lib/spiderfw/model/model.rb

@@ -7,7 +7,8 @@ module Spider
     module Model
         
         @base_types = [
-            String, Spider::DataTypes::Text, Fixnum, Float, BigDecimal, Date, DateTime, Spider::DataTypes::Bool
+            String, Spider::DataTypes::Text, Fixnum, Float, BigDecimal, Date, DateTime, Time,
+            Spider::DataTypes::Bool
         ]
         
         # Base types are:
@@ -47,20 +48,17 @@ module Spider
                 
             }
             return klass if base_types.include?(klass)
+            return klass if klass <= Spider::Model::BaseModel
             return t if t = map_types[klass]
             return klass.maps_to if (klass.subclass_of?(Spider::DataType) && klass.maps_to)
             return klass.superclass if klass.superclass
             return nil
         end
-        
-        # FIXME: Tread global variables are no good in no-threaded mode
-        def self.unit_of_work #:nodoc:
-            Thread.current[:unit_of_work]
-        end
+
         
         # Returns the identity-mapped object
-        def self.get(model, val)
-            if (!val.is_a?(Hash))
+        def self.get(model, val=nil, set_loaded=false)
+            if (val && !val.is_a?(Hash))
                 if (model.primary_keys.length == 1)
                     val = {model.primary_keys[0].name => val}
                 else
@@ -68,7 +66,7 @@ module Spider
                 end
             end
             if identity_mapper
-                return identity_mapper.get(model, val)
+                return identity_mapper.get(model, val, set_loaded)
             else
                 return model.new(val)
             end
@@ -83,22 +81,69 @@ module Spider
             end
         end
         
-        # FIXME: no good
         def self.identity_mapper #:nodoc:
-            Thread.current[:identity_mapper]
+            Spider.current[:identity_mapper]
         end
         
-        # FIXME: no good
         def self.identity_mapper=(im) #:nodoc:
-            Thread.current[:identity_mapper] = im
+            Spider.current[:identity_mapper] = im
+        end
+        
+        def self.start_unit_of_work
+            uow = UnitOfWork.new
+            uow.start
+        end
+        
+        def self.stop_unit_of_work
+            Spider.current[:unit_of_work].stop
         end
         
-        # Creates a new unit of work with the proc
-        def self.with_unit_of_work(&proc) #:nodoc: TODO: test
-            return if unit_of_work
-            UnitOfWork.new(&proc)
+        def self.unit_of_work(&proc) #:nodoc:
+            uow = Spider.current[:unit_of_work]
+            if !uow
+                if proc
+                    uow = UnitOfWork.new(&proc)
+                end
+            end
+            return uow
+        end
+        
+        
+        def self.unit_of_work=(uow)
+            Spider.current[:unit_of_work] = uow
+        end
+        
+        def self.with_unit_of_work(&proc)
+            with_identity_mapper do
+                return unit_of_work(&proc)
+            end
         end
         
+        def self.no_unit_of_work(&proc)
+            uow = self.unit_of_work
+            self.unit_of_work = nil
+            yield
+            self.unit_of_work = uow
+        end
+        
+        def self.no_identity_mapper(&proc)
+            im = self.identity_mapper
+            self.identity_mapper = nil
+            yield
+            self.identity_mapper = im
+        end
+        
+        def self.no_context(&proc)
+            uow = self.unit_of_work
+            self.unit_of_work = nil
+            im = self.identity_mapper
+            self.identity_mapper = nil
+            yield
+            self.identity_mapper = im
+            self.unit_of_work = uow
+            
+        end
+                
         # Executes the block in the context of the main IdentityMapper.
         def self.with_identity_mapper(&proc)
             if identity_mapper
@@ -110,6 +155,19 @@ module Spider
             end
         end
         
+        def self.in_unit(&proc)
+            uow = self.unit_of_work
+            self.start_unit_of_work unless uow
+            self.with_identity_mapper do
+                yield Spider::Model.unit_of_work
+                unless uow
+                    self.unit_of_work.commit
+                    self.stop_unit_of_work 
+                end
+            end
+            
+        end
+        
         # Syncs the schema with the storage.
         #--
         # FIXME: this is clearly db specific. Move somewhere else.
@@ -207,6 +265,9 @@ module Spider
             
         end
         
+        class TypeError < ArgumentError
+        end
+        
         def self.sort(models)
 
             sorter = Sorter.new(models)

data/lib/spiderfw/model/model_hash.rb

@@ -31,7 +31,7 @@ module Spider; module Model
                 end
                 val = n
             end
-            key = key.name if key.class == Element
+            key = key.name if key.is_a?(Element)
             parts = key.to_s.split('.', 2)
             return super(key.to_sym, val) unless parts[1]
             parts[0] = parts[0].to_sym
@@ -41,7 +41,7 @@ module Spider; module Model
         
         def [](key)
             # TODO: deep
-            key = key.name if key.class == Element
+            key = key.name if key.is_a?(Element)
             super(key.to_sym)
         end
         

data/lib/spiderfw/model/query.rb

@@ -19,6 +19,8 @@ module Spider; module Model
         attr_reader :condition
         # The Request instance
         attr_reader :request
+        attr_reader :page_rows
+        attr_reader :page
         
         # Instantiates a new query, calling Condition#where on the condition.
         def self.where(*params)
@@ -118,6 +120,21 @@ module Spider; module Model
            @request.with_superclass
        end
        
+       def first
+           self.limit = 1
+       end
+       
+       def page(page, rows)
+           page = page.to_i
+           page = 1 if page == 0
+           @page_rows = rows
+           @page = page
+           offset = ((page - 1) * rows)
+           self.limit = rows
+           self.offset = offset
+           self
+       end
+       
        ##############################
        # information methods        #
        ##############################

data/lib/spiderfw/model/query_set.rb

@@ -11,6 +11,8 @@ module Spider; module Model
         attr_accessor :_parent
         # Element inside the _parent pointing to this QuerySet.
         attr_accessor :_parent_element
+        # Disables parent setting for this QuerySet
+        attr_accessor :_no_parent
         # Raw data returned by the mapper, if requested.
         attr_reader :raw_data
         # An Hash of autoloaded elements.
@@ -46,6 +48,8 @@ module Spider; module Model
         attr_accessor :append_element
         # (bool) If false, prevents the QuerySet from loading.
         attr_accessor :loadable # :nodoc: TODO: remove?
+        # Don't put this queryset's objects into the IdentityMapper
+        attr_accessor :_no_identity_mapper
         
         # Instantiates a non-autoloading queryset
         def self.static(model, query_or_val=nil)
@@ -186,7 +190,7 @@ module Spider; module Model
             array_index = (index - start) + 1
             load_to_index(index) unless (@objects[array_index] && (!@fetch_window || @window_current_start == start)) || loaded?(index) || !autoload?
             val = @objects[array_index]
-            val.set_parent(self, nil) if val
+            val.set_parent(self, nil) if val && !@_no_parent
             return val
         end
         
@@ -204,15 +208,16 @@ module Spider; module Model
         
         # Checks contained objects' loaded elements.
         def update_loaded_elements
+
             return if currently_empty?
             f_loaded = {}
+            @loaded_elements = {}
+            @loaded_elements.merge!(@objects[0].loaded_elements)
             self.each_current do |obj|
-                @loaded_elements.each do |el|
+                @loaded_elements.each do |el, val|
                     f_loaded[el] = false unless obj.loaded_elements[el]
                 end
             end
-            @loaded_elements = {}
-            @loaded_elements.merge!(@objects[0].loaded_elements)
             @loaded_elements.merge!(f_loaded)
         end
         
@@ -282,7 +287,7 @@ module Spider; module Model
         
         # Index objects by some elements.
         def index_by(*elements)
-            names = elements.map{ |el| (el.class == Spider::Model::Element) ? el.name.to_s : el.to_s }
+            names = elements.map{ |el| (el.is_a?(Spider::Model::Element)) ? el.name.to_s : el.to_s }
             index_name = names.sort.join(',')
             @index_lookup[index_name] = {}
             reindex
@@ -331,10 +336,7 @@ module Spider; module Model
             @objects = []
             @index_lookup.each_key{ |k| @index_lookup[k] = {} }
         end
-        
-        # Remove when merging
-        alias :map_array :map
-        
+                
         # Iterates on currently loaded objects
         def each_current
             @objects.each { |obj| yield obj }
@@ -387,6 +389,26 @@ module Spider; module Model
             reindex
         end
         
+        def include?(val)
+            self.each do |obj|
+                if val.is_a?(BaseModel)
+                    return true if obj == val
+                elsif val.is_a?(Hash)
+                    has_all = true
+                    val.each do |k, v|
+                        unless obj.get(k) == v
+                            has_all = false
+                            break
+                        end
+                        return true if has_all
+                    end
+                elsif @model.primary_keys.length == 1
+                    return true if obj.primary_keys[0] == val
+                end
+            end
+            return false
+        end
+        
         # Searchs the index for objects matching the given params.
         def find(params)
             sorted_keys = params.keys.map{|k| k.to_s}.sort.map{|k| k.to_sym}
@@ -486,6 +508,10 @@ module Spider; module Model
         def save
             no_autoload(false){ each{ |obj| obj.save } }
         end
+        
+        def save!
+            no_autoload(false){ each{ |obj| obj.save! } }
+        end
 
         # Calls #BaseModel.insert on each object in the QuerySet.        
         def insert
@@ -555,8 +581,33 @@ module Spider; module Model
         
         # Prints an ASCII table
         def table
+            
+            # Functions for determining terminal size:
+            # Copyright (c) 2010 Gabriel Horner, MIT LICENSE
+            # http://github.com/cldwalker/hirb.git
+            
+            # Determines if a shell command exists by searching for it in ENV['PATH'].
+            def command_exists?(command)
+              ENV['PATH'].split(File::PATH_SEPARATOR).any? {|d| File.exists? File.join(d, command) }
+            end
+
+            # Returns [width, height] of terminal when detected, nil if not detected.
+            # Think of this as a simpler version of Highline's Highline::SystemExtensions.terminal_size()
+            def detect_terminal_size
+              if (ENV['COLUMNS'] =~ /^\d+$/) && (ENV['LINES'] =~ /^\d+$/)
+                [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
+              elsif (RUBY_PLATFORM =~ /java/ || !STDIN.tty?) && command_exists?('tput')
+                [`tput cols`.to_i, `tput lines`.to_i]
+              else
+                command_exists?('stty') ? `stty size`.scan(/\d+/).map { |s| s.to_i }.reverse : nil
+              end
+            rescue
+              nil
+            end
+            
+            
             return print("Empty\n") if length < 1
-            columns = ENV['COLUMNS'].to_i || 80
+            columns = detect_terminal_size[0]
             a = to_flat_array
             m_sizes = Hash.new(0) # one separator column
             a.each do |row|
@@ -578,12 +629,15 @@ module Spider; module Model
                     sizes[k] += 1; avail -= 1
                 end
             end
+            sizes.each do |k, v|
+                sizes[k] = v.floor
+            end
             print "\n"
             1.upto(columns) { print "-" }
             print "\n"
             elements.each do |el|
                 print "|"
-                print el.label[0..sizes[el.name]].ljust(sizes[el.name])
+                print el.label[0..sizes[el.name]-1].ljust(sizes[el.name])
             end
             print "\n"
             1.upto(columns) { print "-" }
@@ -591,7 +645,7 @@ module Spider; module Model
             a.each do |row|
                 elements.each do |el|
                     print "|"
-                    print row[el.name][0..sizes[el.name]].ljust(sizes[el.name])
+                    print row[el.name][0..sizes[el.name]-1].ljust(sizes[el.name])
                 end
                 print "\n"
             end
@@ -604,6 +658,10 @@ module Spider; module Model
             self.map{ |row| row }
         end
         
+        def reverse
+            self.to_a.reverse
+        end
+        
         def map_current
             a = []
             each_current{ |row| a << yield(row) }
@@ -625,6 +683,10 @@ module Spider; module Model
             @objects.reject!(&proc)
         end
         
+        def empty!
+            @objects = []
+        end
+        
         def to_s
             self.map{ |o| o.to_s }.join(', ')
         end
@@ -663,13 +725,13 @@ module Spider; module Model
         
         # Registers that the element has been loaded.
         def element_loaded(element)
-            element = element.name if (element.class == Element)
+            element = element.name if element.is_a?(Element)
             @loaded_elements[element] = true
         end
         
         # Returns whether the element has been loaded from the Storage.
         def element_loaded?(element)
-            element = element.name if (element.class == Element)
+            element = element.name if element.is_a?(Element)
             @loaded_elements[element]
         end
         
@@ -711,6 +773,16 @@ module Spider; module Model
             return self
         end
         
+        def page(page, rows)
+            @query.page(page, rows)
+            self
+        end
+        
+        def pages
+            return nil unless @query.limit
+            (self.total_rows.to_f / @query.limit).ceil
+        end
+        
         # def unit_of_work
         #     return Spider::Model.unit_of_work
         # end

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

@@ -3,6 +3,7 @@ module Spider; module Model; module Storage
     class BaseStorage
         include Spider::Logger
         attr_reader :url
+        attr_accessor :instance_name
         
         def self.sequence_sync
             @sequence_sync ||= Sync.new

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

@@ -16,11 +16,11 @@ module Spider; module Model; module Storage; module Db
             :foreign_keys => true
         }
         @reserved_keywords = superclass.reserved_keywords
-        @safe_conversions = {
+        @safe_conversions = DbStorage.safe_conversions.merge({
             'CHAR' => ['VARCHAR', 'CLOB'],
             'VARCHAR' => ['CLOB'],
             'NUMBER' => ['VARCHAR']
-        }
+        })
         @type_synonyms = {
             'BLOB' => ['TEXT']
         }
@@ -104,24 +104,29 @@ module Spider; module Model; module Storage; module Db
             end 
         end
         
-        def parse_url(url)
+        def self.parse_url(url)
             # db:mysql://<username:password>@<host>:<port>/<database>
             if (url =~ /.+:\/\/(?:(.+):(.+)@)?(.+)?\/(.+)/)
-                @user = $1
-                @pass = $2
-                @location = $3
-                @db_name = $4
+                user = $1
+                pass = $2
+                location = $3
+                db_name = $4
             else
                 raise ArgumentError, "Mysql url '#{url}' is invalid"
             end
-            if (@location =~ /localhost:(\/.+)/)
-                @host = 'localhost'
-                @sock = $1
+            if (location =~ /localhost:(\/.+)/)
+                host = 'localhost'
+                sock = $1
             else
-                @location =~ /(.+)(?::(\d+))/
-                @host = $1
-                @port = $2
+                location =~ /(.+)(?::(\d+))/
+                host = $1
+                port = $2
             end
+            return [host, user, pass, db_name, port, sock]
+        end
+        
+        def parse_url(url)
+            @host, @user, @pass, @db_name, @port, @sock = self.class.parse_url(url)
             @connection_params = [@host, @user, @pass, @db_name, @port, @sock]
         end
         
@@ -168,6 +173,7 @@ module Spider; module Model; module Storage; module Db
                     debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
                     debug("mysql executing:\n#{sql}\n[#{debug_vars_str}]")
                 end
+                query_start
                 stmt = connection.prepare(sql)
                 curr[:stmt] = stmt
                 res = stmt.execute(*bind_vars)
@@ -208,6 +214,7 @@ module Spider; module Model; module Storage; module Db
                     raise exc
                 end
             ensure
+                query_finished
                 release if curr[:conn] && !in_transaction?
             end
          end
@@ -231,8 +238,12 @@ module Spider; module Model; module Storage; module Db
              case type.name
              when 'String'
                  return value.to_s
-             when 'Date', 'DateTime'
+             when 'Date'
+                 return value.strftime("%Y-%m-%d")
+             when 'DateTime'
                  return value.strftime("%Y-%m-%dT%H:%M:%S")
+             when 'Time'
+                 return value.strftime("%H:%M:%S")
              when 'Fixnum'
                  return value.to_i
              end
@@ -247,6 +258,8 @@ module Spider; module Model; module Storage; module Db
                  return type.civil(value.year, value.month, value.day, value.hour, value.minute, value.second, @@time_offset)
              when 'Date'
                  return type.civil(value.year, value.month, value.day)
+             when 'Time'
+                 return type.local(2000, 1, 1, value.hour, value.minute, value.second)
              end
              return super(type, value)
          end
@@ -287,6 +300,18 @@ module Spider; module Model; module Storage; module Db
              return sql
          end
          
+         def function(func)
+             return super unless func.func_name == :concat
+             fields = func.elements.map{ |func_el|
+                 if (func_el.is_a?(Spider::QueryFuncs::Function))
+                     function(func_el)
+                 else
+                     func.mapper_fields[func_el]
+                 end
+             }
+             return "CONCAT(#{fields.map{ |f| "COALESCE(#{f}, '')" }.join(', ')})"
+         end
+         
          ##############################################################
          #   Methods to get information from the db                   #
          ##############################################################
@@ -374,8 +399,12 @@ module Spider; module Model; module Storage; module Db
                  'INT'
              when 'Float'
                  'FLOAT'
-             when 'Date', 'DateTime'
+             when 'Date'
+                 'DATE'
+             when 'DateTime'
                  'DATETIME'
+             when 'Time'
+                 'TIME'
              when 'Spider::DataTypes::Binary'
                  'BLOB'
              when 'Spider::DataTypes::Bool'

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

@@ -90,7 +90,7 @@ module Spider; module Model; module Storage; module Db
          def sql_drop_primary_key(table_name)
              constraint_name = nil
              connection do |conn|
-                 res = conn.exec("SELECT CONSTRAINT_NAME FROM USER_CONSTRAINTS cons, user_cons_columns cols 
+                 res = conn.exec("SELECT cons.CONSTRAINT_NAME FROM USER_CONSTRAINTS cons, user_cons_columns cols 
                                     WHERE cons.constraint_type = 'P'
                                     AND cons.constraint_name = cols.constraint_name
                                     AND cols.table_name = '#{table_name}'")
@@ -139,7 +139,6 @@ module Spider; module Model; module Storage; module Db
                  end
              end
              keys = sql_keys(query)
-             order = sql_order(query)
              tables_sql, tables_values = sql_tables(query)
              sql = "SELECT #{keys} FROM #{tables_sql} "
              bind_vars += tables_values
@@ -159,12 +158,14 @@ module Spider; module Model; module Storage; module Db
                  end
                  if (!query[:joins].empty?)
                      data_tables_sql = query[:order_on_different_table] ? tables_sql : query[:tables].join(', ')
-                     pk_sql = query[:primary_keys].join(', ')
+                     pk_sql = query[:primary_keys].reject{ |pk| pk.is_a?(Db::FieldExpression) }.join(', ')
                      distinct_sql = "SELECT DISTINCT #{pk_sql} FROM #{tables_sql}"
                      distinct_sql += " WHERE #{where}" if where && !where.empty?
-                     data_sql = "SELECT #{keys} FROM #{data_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})"
+                     data_sql += " order by #{order}" unless order.blank?
                  else
-                     data_sql = "#{sql} order by #{order}"
+                     data_sql = sql
+                     data_sql += " order by #{order}" unless order.blank?
                  end
                  count_sql = "SELECT /*+ FIRST_ROWS(n) */ a.*, ROWNUM oci8_row_num FROM (#{data_sql}) a"
                  if limit
@@ -277,7 +278,7 @@ module Spider; module Model; module Storage; module Db
                  FROM user_constraints cons, user_cons_columns cols
                  WHERE cons.constraint_type = 'P'
                  AND cons.constraint_name = cols.constraint_name
-                 AND cols.table_name = '#{table}'")
+                 AND cols.table_name = '#{table}'".split("\n").join(' '))
                  res.each do |h|
                      primary_keys << h['COLUMN_NAME']
                  end
@@ -293,7 +294,7 @@ module Spider; module Model; module Storage; module Db
                        on cc.r_constraint_name = cols.constraint_name 
                       and cons.position = cols.position
                  WHERE cc.constraint_type = 'R'
-                 AND cons.table_name = '#{table}'")
+                 AND cons.table_name = '#{table}'".split("\n").join(' '))
                  res.each do |h|
                      fk_name = h['CONSTRAINT_NAME']
                      o_foreign_keys[fk_name] ||= {:table => h['REFERENCED_TABLE'], :columns => {}}

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

@@ -95,6 +95,7 @@ module Spider; module Model; module Storage; module Db; module Connectors
                     debug_vars_str = debug_vars ? debug_vars.join(', ') : ''
                     debug("oci8 #{connection} executing:\n#{sql}\n[#{debug_vars_str}]")
                 end
+                query_start
                 cursor = connection.parse(sql)
                 return cursor if (!cursor || cursor.is_a?(Fixnum))
                 bind_vars.each_index do |i|
@@ -139,8 +140,13 @@ module Spider; module Model; module Storage; module Db; module Connectors
                 rollback! if in_transaction?
                 #curr[:conn].logoff
                 release
-                raise
+                if (exc.message =~ /ORA-00001/)
+                    raise Spider::Model::Storage::DuplicateKey
+                else
+                    raise exc
+                end
             ensure
+                query_finished
                 cursor.close if cursor
                 release if curr[:conn] && !in_transaction?
             end

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

@@ -225,6 +225,19 @@ module Spider; module Model; module Storage; module Db
             "#<#{self.class.name}:#{self.object_id} @name=\"#{@name}\", @table=#<Spider::Model::Storage::Db::Table:#{@table.object_id} #{@table.name}> >"
         end
         
+        def ==(other)
+            @table == other.table && @name == other.name
+        end
+        
+        
+        def eql?(other)
+            self == other
+        end
+        
+        def hash
+            to_s.hash
+        end
+        
     end
     
     class FieldExpression < Field