epugh-sequel 0.0.0

data/lib/sequel/extensions/pretty_table.rb

@@ -0,0 +1,78 @@
+module Sequel
+  class Dataset
+    # Pretty prints the records in the dataset as plain-text table.
+    def print(*cols)
+      Sequel::PrettyTable.print(naked.all, cols.empty? ? columns : cols)
+    end
+  end
+
+  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
+
+    private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+  end
+end
+

data/lib/sequel/extensions/query.rb

@@ -0,0 +1,48 @@
+module Sequel
+  class Database
+    # Return a dataset modified by the query block
+    def query(&block)
+      dataset.query(&block)
+    end
+  end
+
+  class Dataset
+    # Translates a query block into a dataset. Query blocks can be useful
+    # when expressing complex SELECT statements, e.g.:
+    #
+    #   dataset = DB[:items].query do
+    #     select :x, :y, :z
+    #     filter{|o| (o.x > 1) & (o.y > 2)}
+    #     order :z.desc
+    #   end
+    #
+    # Which is the same as:
+    #
+    #  dataset = DB[:items].select(:x, :y, :z).filter{|o| (o.x > 1) & (o.y > 2)}.order(:z.desc)
+    #
+    # Note that inside a call to query, you cannot call each, insert, update,
+    # or delete (or any method that calls those), or Sequel will raise an
+    # error.
+    def query(&block)
+      copy = clone({})
+      copy.extend(QueryBlockCopy)
+      copy.instance_eval(&block)
+      clone(copy.opts)
+    end
+
+    # Module used by Dataset#query that has the effect of making all
+    # dataset methods into !-style methods that modify the receiver.
+    module QueryBlockCopy
+      %w'each insert update delete'.each do |meth|
+        define_method(meth){|*args| raise Error, "##{meth} cannot be invoked inside a query block."}
+      end
+
+      # Merge the given options into the receiver's options and return the receiver
+      # instead of cloning the receiver.
+      def clone(opts = nil)
+        @opts.merge!(opts)
+        self
+      end
+    end
+  end
+end

data/lib/sequel/extensions/string_date_time.rb

@@ -0,0 +1,47 @@
+# This file contains the previous extensions to String for date/time
+# conversions.  These are provided mainly for backward compatibility,
+# Sequel now uses a module level method instead of extending string
+# to handle the internal conversions.
+
+class String
+  # Converts a string into a Date object.
+  def to_date
+    begin
+      Date.parse(self, Sequel.convert_two_digit_years)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a DateTime object.
+  def to_datetime
+    begin
+      DateTime.parse(self, Sequel.convert_two_digit_years)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Time or DateTime object, depending on the
+  # value of Sequel.datetime_class
+  def to_sequel_time
+    begin
+      if Sequel.datetime_class == DateTime
+        DateTime.parse(self, Sequel.convert_two_digit_years)
+      else
+        Sequel.datetime_class.parse(self)
+      end
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Time object.
+  def to_time
+    begin
+      Time.parse(self)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
+    end
+  end
+end

data/lib/sequel/metaprogramming.rb

@@ -0,0 +1,44 @@
+module Sequel
+  # Contains methods that ease metaprogramming, used by some of Sequel's classes.
+  module Metaprogramming
+    # Add methods to the object's metaclass
+    def meta_def(name, &block)
+      meta_eval{define_method(name, &block)}
+    end 
+  
+    private
+  
+    # Make a singleton/class attribute accessor method(s).
+    # Replaces the construct:
+    #
+    #   class << self
+    #     attr_accessor *meths
+    #   end
+    def metaattr_accessor(*meths)
+      meta_eval{attr_accessor(*meths)}
+    end
+  
+    # Make a singleton/class method(s) private.
+    # Make a singleton/class attribute reader method(s).
+    # Replaces the construct:
+    #
+    #   class << self
+    #     attr_reader *meths
+    #   end
+    def metaattr_reader(*meths)
+      meta_eval{attr_reader(*meths)}
+    end
+  
+    # Evaluate the block in the context of the object's metaclass
+    def meta_eval(&block)
+      metaclass.instance_eval(&block)
+    end 
+  
+    # The hidden singleton lurks behind everyone
+    def metaclass
+      class << self
+        self
+      end 
+    end 
+  end
+end

data/lib/sequel/migration.rb

@@ -0,0 +1,212 @@
+module Sequel
+  # The Migration class describes a database migration that can be reversed.
+  # The migration looks very similar to ActiveRecord (Rails) migrations, e.g.:
+  #
+  #   class CreateSessions < Sequel::Migration
+  #     def up
+  #       create_table :sessions do
+  #         primary_key :id
+  #         String :session_id, :size => 32, :unique => true
+  #         DateTime :created_at
+  #         text :data
+  #       end
+  #     end
+  # 
+  #     def down
+  #       # You can use raw SQL if you need to
+  #       self << 'DROP TABLE sessions'
+  #     end
+  #   end
+  #
+  #   class AlterItems < Sequel::Migration
+  #     def up
+  #       alter_table :items do
+  #         add_column :category, String, :default => 'ruby'
+  #       end
+  #     end
+  # 
+  #     def down
+  #       alter_table :items do
+  #         drop_column :category
+  #       end  
+  #     end
+  #   end
+  #
+  # 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.connect('sqlite://mydb')
+  #   CreateSessions.apply(DB, :up)
+  #
+  # See Sequel::Schema::Generator for the syntax to use for creating tables,
+  # and Sequel::Schema::AlterTableGenerator for the syntax to use when
+  # altering existing tables.  Migrations act as a proxy for the database
+  # given in #apply, so inside #down and #up, you can act as though self
+  # refers to the database.  So you can use any of the Sequel::Database
+  # instance methods directly.
+  class Migration
+    # Creates a new instance of the migration and sets the @db attribute.
+    def initialize(db)
+      @db = db
+    end
+    
+    # Applies the migration to the supplied database in the specified
+    # direction.
+    def self.apply(db, direction)
+      obj = new(db)
+      case direction
+      when :up
+        obj.up
+      when :down
+        obj.down
+      else
+        raise ArgumentError, "Invalid migration direction specified (#{direction.inspect})"
+      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)
+    end
+
+    # The default up action does nothing
+    def up
+    end
+  end
+
+  # The Migrator module performs migrations based on migration files in a 
+  # specified directory. The migration files should be named using the
+  # following pattern (in similar fashion to ActiveRecord migrations):
+  # 
+  #   <version>_<title>.rb
+  #
+  # For example, the following files are considered migration files:
+  #   
+  #   001_create_sessions.rb
+  #   002_add_data_column.rb
+  #   ...
+  #
+  # The migration files should contain one or more migration classes based
+  # on Sequel::Migration.
+  #
+  # Migrations are generally run via the sequel command line tool,
+  # using the -m and -M switches.  The -m switch specifies the migration
+  # directory, and the -M switch specifies the version to which to migrate.
+  # 
+  # You can apply migrations using the Migrator API, as well (this is necessary
+  # if you want to specify the version from which to migrate in addition to the version
+  # to which to migrate).
+  # To apply a migration, the #apply method must be invoked with the database
+  # instance, the directory of migration files and the target version. If
+  # no current version is supplied, it is read from the database. The migrator
+  # automatically creates a schema_info table in the database to keep track
+  # of the current migration version. If no migration version is stored in the
+  # database, the version is considered to be 0. If no target version is 
+  # specified, the database is migrated to the latest version available in the
+  # migration directory.
+  #
+  # For example, to migrate the database to the latest version:
+  #
+  #   Sequel::Migrator.apply(DB, '.')
+  #
+  # 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
+    # table is automatically created and maintained by the apply function.
+    def self.apply(db, directory, target = nil, current = nil)
+      # determine current and target version and direction
+      current ||= get_current_migration_version(db)
+      target ||= latest_migration_version(directory)
+      raise Error, "No current version available" if current.nil?
+      raise Error, "No target version available" if target.nil?
+
+      direction = current < target ? :up : :down
+      
+      classes = migration_classes(directory, target, current, direction)
+      
+      db.transaction do
+        classes.each {|c| c.apply(db, direction)}
+        set_current_migration_version(db, target)
+      end
+      
+      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)
+      range = direction == :up ?
+        (current + 1)..target : (target + 1)..current
+
+      # Remove class definitions
+      Migration.descendants.each do |c|
+        Object.send(:remove_const, c.to_s) rescue nil
+      end
+      Migration.descendants.clear # remove any defined migration classes
+
+      # load migration files
+      migration_files(directory, range).each {|fn| load(fn)}
+      
+      # get migration classes
+      classes = Migration.descendants
+      classes.reverse! if direction == :down
+      classes
+    end
+    
+    # Returns any found migration files in the supplied directory.
+    def self.migration_files(directory, range = nil)
+      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 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)
+      dataset.send(dataset.first ? :update : :<<, :version => version)
+    end
+  end
+end

data/lib/sequel/model.rb

@@ -0,0 +1,142 @@
+require 'sequel/core'
+
+module Sequel
+  # Holds the nameless subclasses that are created with
+  # Sequel::Model(), necessary for reopening subclasses with the
+  # Sequel::Model() superclass specified.
+  @models = {}
+
+  # Lets you create a Model subclass with its dataset already set.
+  # source can be an existing dataset or a symbol (in which case
+  # it will create a dataset using the default database with 
+  # source as the table name).
+  #
+  # Example:
+  #   class Comment < Sequel::Model(:something)
+  #     table_name # => :something
+  #   end
+  def self.Model(source)
+    @models[source] ||= Class.new(Model).set_dataset(source)
+  end
+
+  # Model has some methods that are added via metaprogramming:
+  #
+  # * All of the methods in DATASET_METHODS have class methods created that call
+  #   the Model's dataset with the method of the same name with the given
+  #   arguments.
+  # * All of the methods in HOOKS have class methods created that accept
+  #   either a method name symbol or an optional tag and a block.  These
+  #   methods run the code as a callback at the specified time.  For example:
+  #
+  #     Model.before_save :do_something
+  #     Model.before_save(:do_something_else){ self.something_else = 42}
+  #     object = Model.new
+  #     object.save
+  #
+  #   Would run the object's :do_something method following by the code
+  #   block related to :do_something_else.  Note that if you specify a
+  #   block, a tag is optional.  If the tag is not nil, it will overwrite
+  #   a previous block with the same tag.  This allows hooks to work with
+  #   systems that reload code.
+  # * All of the methods in HOOKS also create instance methods, but you
+  #   should not override these instance methods.
+  # * The following instance_methods all call the class method of the same
+  #   name: columns, dataset, db, primary_key, db_schema.
+  # * The following class level attr_readers are created: allowed_columns,
+  #   dataset_methods, primary_key, and restricted_columns.
+  #   You should not usually need to  access these directly.
+  # * All validation methods also accept the options specified in #validates_each,
+  #   in addition to the options specified in the RDoc for that method.
+  # * The following class level attr_accessors are created: raise_on_typecast_failure,
+  #   raise_on_save_failure, strict_param_setting, typecast_empty_string_to_nil,
+  #   and typecast_on_assignment:
+  #
+  #     # Don't raise an error if a validation attempt fails in
+  #     # save/create/save_changes/etc.
+  #     Model.raise_on_save_failure = false
+  #     Model.before_save{false}
+  #     Model.new.save # => nil
+  #     # Don't raise errors in new/set/update/etc. if an attempt to
+  #     # access a missing/restricted method occurs (just silently
+  #     # skip it)
+  #     Model.strict_param_setting = false
+  #     Model.new(:id=>1) # No Error
+  #     # Don't typecast attribute values on assignment
+  #     Model.typecast_on_assignment = false
+  #     m = Model.new
+  #     m.number = '10'
+  #     m.number # => '10' instead of 10
+  #     # Don't typecast empty string to nil for non-string, non-blob columns.
+  #     Model.typecast_empty_string_to_nil = false
+  #     m.number = ''
+  #     m.number # => '' instead of nil
+  #     # Don't raise if unable to typecast data for a column
+  #     Model.typecast_empty_string_to_nil = true
+  #     Model.raise_on_typecast_failure = false
+  #     m.not_null_column = '' # => nil
+  #     m.number = 'A' # => 'A'
+  #
+  # * The following class level method aliases are defined:
+  #   * Model.dataset= => set_dataset
+  #   * Model.is_a => is
+  class Model
+    # Dataset methods to proxy via metaprogramming
+    DATASET_METHODS = %w'<< all avg count delete distinct eager eager_graph each each_page 
+       empty? except exclude filter first from from_self full_outer_join get graph 
+       group group_and_count group_by having inner_join insert 
+       insert_multiple intersect interval join join_table last 
+       left_outer_join limit map multi_insert naked order order_by order_more 
+       paginate print query range reverse_order right_outer_join select 
+       select_all select_more server set set_graph_aliases single_value to_csv to_hash
+       transform union unfiltered unordered update where with_sql'.map{|x| x.to_sym}
+  
+    # Regular expression that much match for a public instance method of a plugin
+    # dataset to have a model method created that calls it
+    DATASET_METHOD_RE = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+    # Empty instance variables, for -w compliance
+    EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@transform, :@db, :@skip_superclass_validations]
+
+    # Hooks that are safe for public use
+    HOOKS = [:after_initialize, :before_create, :after_create, :before_update,
+      :after_update, :before_save, :after_save, :before_destroy, :after_destroy,
+      :before_validation, :after_validation]
+
+    # Instance variables that are inherited in subclasses
+    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@dataset_methods=>:dup, 
+      :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
+      :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+      :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
+      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
+      :@raise_on_typecast_failure=>nil, :@association_reflections=>:dup}
+
+    # The setter methods (methods ending with =) that are never allowed
+    # to be called automatically via set.
+    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure= raise_on_typecast_failure="
+
+    @allowed_columns = nil
+    @association_reflections = {}
+    @cache_store = nil
+    @cache_ttl = nil
+    @db = nil
+    @db_schema = nil
+    @dataset_method_modules = []
+    @dataset_methods = {}
+    @overridable_methods_module = nil
+    @primary_key = :id
+    @raise_on_save_failure = true
+    @raise_on_typecast_failure = true
+    @restrict_primary_key = true
+    @restricted_columns = nil
+    @simple_pk = nil
+    @simple_table = nil
+    @skip_superclass_validations = nil
+    @strict_param_setting = true
+    @transform = nil
+    @typecast_empty_string_to_nil = true
+    @typecast_on_assignment = true
+    @use_transactions = true
+  end
+end
+
+Sequel.require %w"inflections plugins base association_reflection associations exceptions errors deprecated", "model"