sequel_core 1.5.1 → 2.0.0

data/lib/sequel_core/exceptions.rb

@@ -1,37 +1,42 @@
 module Sequel
   # Represents an error raised in Sequel code.
-  class Error < StandardError
+  class Error < ::StandardError
     
-    # Error raised when an invalid statement is executed.
-    class InvalidStatement < Error; end
-
-    # Rollback is a special error used to rollback a transactions.
-    # A transaction block will catch this error and wont pass further up the stack.
-    class Rollback < Error ; end
+    # Raised when Sequel is unable to load a specified adapter.
+    class AdapterNotFound < Error ; end
     
-    # Represents an invalid value stored in the database.
-    class InvalidValue < Error ; end
+    # Raise when an invalid expression is encountered inside a block filter.
+    class InvalidExpression < Error; end
                                        
-    # Represents an Invalid transform.
-    class InvalidTransform < Error ; end
+    # Represents an Invalid filter.    
+    class InvalidFilter < Error ; end
     
+    # Represents an invalid join type.
+    class InvalidJoinType < Error ; end
+
     # Raised on an invalid operation.
     class InvalidOperation < Error; end
                                        
-    # Represents an Invalid filter.    
-    class InvalidFilter < Error ; end
+    # Error raised when an invalid statement is executed.
+    class InvalidStatement < Error; end
+
+    # Represents an Invalid transform.
+    class InvalidTransform < Error ; end
     
-    class InvalidExpression < Error; end
+    # Represents an invalid value stored in the database.
+    class InvalidValue < Error ; end
                                        
     # Represents an attempt to performing filter operations when no filter has been specified yet.
     class NoExistingFilter < Error ; end
                                        
-    # Represents an invalid join type.
-    class InvalidJoinType < Error ; end
+    # There was an error while waiting on a connection from the connection pool
+    class PoolTimeoutError < Error ; end
                                        
-    class WorkerStop < RuntimeError ; end
+    # Rollback is a special error used to rollback a transactions.
+    # A transaction block will catch this error and won't pass further up the stack.
+    class Rollback < Error ; end
     
-    # Raised when Sequel is unable to load a specified adapter.
-    class AdapterNotFound < Error ; end
+    # Should be raised inside a worker loop to tell it to stop working.
+    class WorkerStop < RuntimeError ; end
   end  
 end

data/lib/sequel_core/migration.rb

@@ -1,6 +1,3 @@
-# The migration code is based on work by Florian Aßmann:
-#   http://code.google.com/p/ruby-sequel/issues/detail?id=23
-
 module Sequel
   # The Migration class describes a database migration that can be reversed.
   # The migration looks very similar to ActiveRecord (Rails) migrations, e.g.:
@@ -23,28 +20,14 @@ module Sequel
   # To apply a migration to a database, you can invoke the #apply with
   # the target database instance and the direction :up or :down, e.g.:
   #
-  #   DB = Sequel.open ('sqlite:///mydb')
+  #   DB = Sequel.open ('sqlite://mydb')
   #   CreateSessions.apply(DB, :up)
-  #
   class Migration
     # Creates a new instance of the migration and sets the @db attribute.
     def initialize(db)
       @db = db
     end
     
-    # Adds the new migration class to the list of Migration descendants.
-    def self.inherited(base)
-      descendants << base
-    end
-    
-    # Returns the list of Migration descendants.
-    def self.descendants
-      @descendants ||= []
-    end
-    
-    def up; end #:nodoc:
-    def down; end #:nodoc:
-    
     # Applies the migration to the supplied database in the specified
     # direction.
     def self.apply(db, direction)
@@ -59,9 +42,27 @@ module Sequel
       end
     end
 
+    # Returns the list of Migration descendants.
+    def self.descendants
+      @descendants ||= []
+    end
+    
+    # Adds the new migration class to the list of Migration descendants.
+    def self.inherited(base)
+      descendants << base
+    end
+    
+    # The default down action does nothing
+    def down
+    end
+    
     # Intercepts method calls intended for the database and sends them along.
     def method_missing(method_sym, *args, &block)
-      @db.send method_sym, *args, &block
+      @db.send(method_sym, *args, &block)
+    end
+
+    # The default up action does nothing
+    def up
     end
   end
 
@@ -96,8 +97,9 @@ module Sequel
   # To migrate the database from version 1 to version 5:
   #
   #   Sequel::Migrator.apply(DB, '.', 5, 1)
-  #
   module Migrator
+    MIGRATION_FILE_PATTERN = /\A\d+_.+\.rb\z/.freeze
+
     # Migrates the supplied database in the specified directory from the
     # current version to the target version. If no current version is
     # supplied, it is extracted from a schema_info table. The schema_info
@@ -121,6 +123,19 @@ module Sequel
       target
     end
 
+    # Gets the current migration version stored in the database. If no version
+    # number is stored, 0 is returned.
+    def self.get_current_migration_version(db)
+      r = schema_info_dataset(db).first
+      r ? r[:version] : 0
+    end
+
+    # Returns the latest version available in the specified directory.
+    def self.latest_migration_version(directory)
+      l = migration_files(directory).last
+      l ? File.basename(l).to_i : nil
+    end
+
     # Returns a list of migration classes filtered for the migration range and
     # ordered according to the migration direction.
     def self.migration_classes(directory, target, current, direction)
@@ -142,50 +157,27 @@ module Sequel
       classes
     end
     
-    MIGRATION_FILE_PATTERN = '[0-9][0-9][0-9]_*.rb'.freeze
-
     # Returns any found migration files in the supplied directory.
     def self.migration_files(directory, range = nil)
-      pattern = File.join(directory, MIGRATION_FILE_PATTERN)
-      files = Dir[pattern].inject([]) do |m, path|
-        m[File.basename(path).to_i] = path
-        m
+      files = []
+      Dir.new(directory).each do |file|
+        files[file.to_i] = File.join(directory, file) if MIGRATION_FILE_PATTERN.match(file)
       end
       filtered = range ? files[range] : files
       filtered ? filtered.compact : []
     end
     
-    # Returns the latest version available in the specified directory.
-    def self.latest_migration_version(directory)
-      l = migration_files(directory).last
-      l ? File.basename(l).to_i : nil
-    end
-
-    # Gets the current migration version stored in the database. If no version
-    # number is stored, 0 is returned.
-    def self.get_current_migration_version(db)
-      r = schema_info_dataset(db).first
-      r ? r[:version] : 0
+    # Returns the dataset for the schema_info table. If no such table
+    # exists, it is automatically created.
+    def self.schema_info_dataset(db)
+      db.create_table(:schema_info) {integer :version} unless db.table_exists?(:schema_info)
+      db[:schema_info]
     end
     
     # Sets the current migration  version stored in the database.
     def self.set_current_migration_version(db, version)
       dataset = schema_info_dataset(db)
-      if dataset.first
-        dataset.update(:version => version)
-      else
-        dataset << {:version => version}
-      end
-    end
-    
-    # Returns the dataset for the schema_info table. If no such table
-    # exists, it is automatically created.
-    def self.schema_info_dataset(db)
-      unless db.table_exists?(:schema_info)
-        db.create_table(:schema_info) {integer :version}
-      end
-
-      db[:schema_info]
+      dataset.send(dataset.first ? :update : :<<, :version => version)
     end
   end
 end

data/lib/sequel_core/object_graph.rb

@@ -68,7 +68,7 @@ module Sequel
       raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
 
       # Join the table early in order to avoid cloning the dataset twice
-      ds = join_table(options[:join_type] || :left_outer, table == table_alias ? table : "#{table} #{table_alias}", join_conditions)
+      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, table_alias)
       opts = ds.opts
 
       # Whether to include the table in the result set
@@ -162,50 +162,51 @@ module Sequel
     end
 
     private
-      # Fetch the rows, split them into component table parts,
-      # tranform and run the row_proc on each part (if applicable),
-      # and yield a hash of the parts.
-      def graph_each(opts, &block)
-        # Reject tables with nil datasets, as they are excluded from
-        # the result set
-        datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
-        # Get just the list of table aliases into a local variable, for speed
-        table_aliases = datasets.collect{|ta,ds| ta}
-        # Get an array of arrays, one for each dataset, with
-        # the necessary information about each dataset, for speed
-        datasets = datasets.collect do |ta, ds|
-          [ta, ds, ds.instance_variable_get(:@transform), ds.row_proc]
+
+    # Fetch the rows, split them into component table parts,
+    # tranform and run the row_proc on each part (if applicable),
+    # and yield a hash of the parts.
+    def graph_each(opts, &block)
+      # Reject tables with nil datasets, as they are excluded from
+      # the result set
+      datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
+      # Get just the list of table aliases into a local variable, for speed
+      table_aliases = datasets.collect{|ta,ds| ta}
+      # Get an array of arrays, one for each dataset, with
+      # the necessary information about each dataset, for speed
+      datasets = datasets.collect do |ta, ds|
+        [ta, ds, ds.instance_variable_get(:@transform), ds.row_proc]
+      end
+      # Use the manually set graph aliases, if any, otherwise
+      # use the ones automatically created by .graph
+      column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
+      fetch_rows(select_sql(opts)) do |r|
+        graph = {}
+        # Create the sub hashes, one per table
+        table_aliases.each{|ta| graph[ta]={}}
+        # Split the result set based on the column aliases
+        # If there are columns in the result set that are
+        # not in column_aliases, they are ignored
+        column_aliases.each do |col_alias, tc|
+          ta, column = tc
+          graph[ta][column] = r[col_alias]
         end
-        # Use the manually set graph aliases, if any, otherwise
-        # use the ones automatically created by .graph
-        column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
-        fetch_rows(select_sql(opts)) do |r|
-          graph = {}
-          # Create the sub hashes, one per table
-          table_aliases.each{|ta| graph[ta]={}}
-          # Split the result set based on the column aliases
-          # If there are columns in the result set that are
-          # not in column_aliases, they are ignored
-          column_aliases.each do |col_alias, tc|
-            ta, column = tc
-            graph[ta][column] = r[col_alias]
-          end
-          # For each dataset, transform and run the row
-          # row_proc if applicable
-          datasets.each do |ta,ds,tr,rp|
-            g = graph[ta]
-            graph[ta] = if g.values.any?
-              g = ds.transform_load(g) if tr
-              g = rp[g] if rp
-              g
-            else
-              nil
-            end
+        # For each dataset, transform and run the row
+        # row_proc if applicable
+        datasets.each do |ta,ds,tr,rp|
+          g = graph[ta]
+          graph[ta] = if g.values.any?
+            g = ds.transform_load(g) if tr
+            g = rp[g] if rp
+            g
+          else
+            nil
           end
-
-          yield graph
         end
-        self
+
+        yield graph
       end
+      self
+    end
   end
 end

data/lib/sequel_core/pretty_table.rb

@@ -1,76 +1,71 @@
-module Sequel
-  module PrettyTable
-    # Prints nice-looking plain-text tables
-    # 
-    #   +--+-------+
-    #   |id|name   |
-    #   |--+-------|
-    #   |1 |fasdfas|
-    #   |2 |test   |
-    #   +--+-------+
-    def self.print(records, columns = nil) # records is an array of hashes
-      columns ||= records_columns(records)
-      sizes = column_sizes(records, columns)
-      
-      puts separator_line(columns, sizes)
-      puts header_line(columns, sizes)
-      puts separator_line(columns, sizes)
-      records.each {|r| puts data_line(columns, sizes, r)}
-      puts separator_line(columns, sizes)
-    end
-  end
-  class << PrettyTable
-    private
-    def records_columns(records)
-      columns = []
-      records.each do |r|
-        if Array === r && (k = r.keys)
-          return k
-        elsif Hash === r
-          r.keys.each {|k| columns << k unless columns.include?(k)}
-        end
-      end
-      columns
-    end
-    
-    def column_sizes(records, columns)
-      sizes = Hash.new {0}
-      columns.each do |c|
-        s = c.to_s.size
-        sizes[c.to_sym] = s if s > sizes[c.to_sym]
-      end
-      records.each do |r|
-        columns.each do |c|
-          s = r[c].to_s.size
-          sizes[c.to_sym] = s if s > sizes[c.to_sym]
-        end
-      end
-      sizes
-    end
-    
-    def separator_line(columns, sizes)
-      l = ''
-      '+' + columns.map {|c| '-' * sizes[c]}.join('+') + '+'
-    end
-    
-    def format_cell(size, v)
-      case v
-      when Bignum, Fixnum
-        "%#{size}d" % v
-      when Float
-        "%#{size}g" % v
-      else
-        "%-#{size}s" % v.to_s
-      end
-    end
-    
-    def data_line(columns, sizes, record)
-      '|' + columns.map {|c| format_cell(sizes[c], record[c])}.join('|') + '|'
-    end
-    
-    def header_line(columns, sizes)
-      '|' + columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') + '|'
-    end
-  end
-end
-
+module Sequel
+  module PrettyTable
+    # Prints nice-looking plain-text tables via puts
+    # 
+    #   +--+-------+
+    #   |id|name   |
+    #   |--+-------|
+    #   |1 |fasdfas|
+    #   |2 |test   |
+    #   +--+-------+
+    def self.print(records, columns = nil) # records is an array of hashes
+      columns ||= records.first.keys.sort_by{|x|x.to_s}
+      sizes = column_sizes(records, columns)
+      sep_line = separator_line(columns, sizes)
+
+      puts sep_line
+      puts header_line(columns, sizes)
+      puts sep_line
+      records.each {|r| puts data_line(columns, sizes, r)}
+      puts sep_line
+    end
+
+    ### Private Module Methods ###
+
+    # Hash of the maximum size of the value for each column 
+    def self.column_sizes(records, columns) # :nodoc:
+      sizes = Hash.new {0}
+      columns.each do |c|
+        s = c.to_s.size
+        sizes[c.to_sym] = s if s > sizes[c.to_sym]
+      end
+      records.each do |r|
+        columns.each do |c|
+          s = r[c].to_s.size
+          sizes[c.to_sym] = s if s > sizes[c.to_sym]
+        end
+      end
+      sizes
+    end
+    
+    # String for each data line
+    def self.data_line(columns, sizes, record) # :nodoc:
+      '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
+    end
+    
+    # Format the value so it takes up exactly size characters
+    def self.format_cell(size, v) # :nodoc:
+      case v
+      when Bignum, Fixnum
+        "%#{size}d" % v
+      when Float
+        "%#{size}g" % v
+      else
+        "%-#{size}s" % v.to_s
+      end
+    end
+    
+    # String for header line
+    def self.header_line(columns, sizes) # :nodoc:
+      '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
+    end
+
+    # String for separtor line
+    def self.separator_line(columns, sizes) # :nodoc:
+      '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
+    end
+
+    metaprivate :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+  end
+end
+