sequel 0.1.5 → 0.1.6

data/CHANGELOG

@@ -1,3 +1,25 @@
+*0.1.6*
+
+* Fixed Model#method_missing to raise for an invalid attribute.
+
+* Fixed PrettyTable to print model objects (thanks snok.)
+
+* Fixed ODBC timestamp conversion to return DateTime rather than Time object (thanks snok.)
+
+* Fixed Model.method_missing (thanks snok.)
+
+* Model.method_missing now creates stubs for calling Model.dataset methods. Methods like Model.each etc are removed.
+
+* Changed default join type to INNER JOIN (thanks snok.)
+
+* Added support for literal expressions, e.g. DB[:items].filter(:col1 => 'col2 - 10'.expr).
+
+* Added Dataset#and.
+
+* SQLite adapter opens a memory DB if no database is specified, e.g. Sequel.open 'sqlite:/'.
+
+* Added Dataset#or, pretty nifty.
+
 *0.1.5*
 
 * Fixed Dataset#join to support multiple joins. Added #left_outer_join, #right_outer_join, #full_outer_join, #inner_join methods.

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.5"
+VERS = "0.1.6"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel/core_ext.rb

@@ -15,6 +15,11 @@ class Array
   end
 end
 
+module Sequel
+  class ExpressionString < ::String
+  end
+end
+
 # String extensions
 class String
   # Converts a string into an SQL string by removing comments.
@@ -28,4 +33,9 @@ class String
   def split_sql
     to_sql.split(';').map {|s| s.strip}
   end
+  
+  # Convert a string into an Expression String
+  def expr
+    Sequel::ExpressionString.new(self)
+  end
 end

data/lib/sequel/dataset.rb

@@ -112,6 +112,7 @@ module Sequel
     # If an unsupported object is given, an exception is raised.
     def literal(v)
       case v
+      when ExpressionString: v
       when String: "'#{v.gsub(/'/, "''")}'"
       when Integer, Float: v.to_s
       when NilClass: NULL
@@ -208,6 +209,9 @@ module Sequel
         fmt = where.to_expressions.map {|e| format_expression(e.left, e.op, e.right)}.
           join(AND_SEPARATOR)
       else
+        # if the expression is compound, it should be parenthesized in order for 
+        # things to be predictable (when using #or and #and.)
+        parenthesize |= where =~ /\).+\(/
         fmt = where
       end
       parenthesize ? "(#{fmt})" : fmt
@@ -298,6 +302,32 @@ module Sequel
         dup_merge(clause => expression_list(block || cond))
       end
     end
+    
+    # Adds an alternate filter to an existing filter using OR. If no filter 
+    # exists an error is raised.
+    def or(*cond, &block)
+      clause = (@opts[:group] ? :having : :where)
+      cond = cond.first if cond.size == 1
+      parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
+      if @opts[clause]
+        l = expression_list(@opts[clause])
+        r = expression_list(block || cond, parenthesize)
+        dup_merge(clause => "#{l} OR #{r}")
+      else
+        raise SequelError, "No existing filter found."
+      end
+    end
+
+    # Adds an further filter to an existing filter using AND. If no filter 
+    # exists an error is raised. This method is identical to #filter except
+    # it expects an existing filter.
+    def and(*cond, &block)
+      clause = (@opts[:group] ? :having : :where)
+      unless @opts[clause]
+        raise SequelError, "No existing filter found."
+      end
+      filter(*cond, &block)
+    end
 
     # Performs the inverse of Dataset#filter.
     #
@@ -337,14 +367,20 @@ module Sequel
       end
     end
     
+    # Adds a UNION clause using a second dataset object. If all is true the
+    # clause used is UNION ALL, which may return duplicate rows.
     def union(dataset, all = false)
       dup_merge(:union => dataset, :union_all => all)
     end
 
+    # Adds an INTERSECT clause using a second dataset object. If all is true 
+    # the clause used is INTERSECT ALL, which may return duplicate rows.
     def intersect(dataset, all = false)
       dup_merge(:intersect => dataset, :intersect_all => all)
     end
 
+    # Adds an EXCEPT clause using a second dataset object. If all is true the
+    # clause used is EXCEPT ALL, which may return duplicate rows.
     def except(dataset, all = false)
       dup_merge(:except => dataset, :except_all => all)
     end
@@ -357,7 +393,7 @@ module Sequel
     }
     
     def join_expr(type, table, expr)
-      join_type = JOIN_TYPES[type || :left_outer]
+      join_type = JOIN_TYPES[type || :inner]
       unless join_type
         raise SequelError, "Invalid join type: #{type}"
       end
@@ -382,13 +418,12 @@ module Sequel
     end
     
     def left_outer_join(table, expr); join_table(:left_outer, table, expr); end
-    alias_method :join, :left_outer_join
     def right_outer_join(table, expr); join_table(:right_outer, table, expr); end
     def full_outer_join(table, expr); join_table(:full_outer, table, expr); end
     def inner_join(table, expr); join_table(:inner, table, expr); end
+    alias_method :join, :inner_join
 
-
-    alias all to_a
+    alias_method :all, :to_a
     
     # Maps field values for each record in the dataset (if a field name is
     # given), or performs the stock mapping functionality of Enumerable.

data/lib/sequel/model.rb

@@ -21,9 +21,9 @@ module Sequel
     def self.dataset
       return @dataset if @dataset
       if !table_name
-        raise RuntimeError, "Table name not specified for class #{self}."
+        raise SequelError, "Table name not specified for #{self}."
       elsif !db
-        raise RuntimeError, "No database connected."
+        raise SequelError, "Database not specified for #{self}."
       end
       @dataset = db[table_name]
       @dataset.model_class = self
@@ -190,21 +190,21 @@ module Sequel
     
     def refresh
       @values = self.class.dataset.naked[primary_key => @pkey] ||
-        (raise RuntimeError, "Record not found")
+        (raise SequelError, "Record not found")
       self
     end
     
-    def self.each(&block); dataset.each(&block); end
-    def self.all; dataset.all; end
-    def self.filter(*arg, &block); dataset.filter(*arg, &block); end
-    def self.exclude(*arg, &block); dataset.exclude(*arg, &block); end
-    def self.order(*arg); dataset.order(*arg); end
-    def self.first(*arg); dataset.first(*arg); end
-    def self.count; dataset.count; end
-    def self.map(*arg, &block); dataset.map(*arg, &block); end
-    def self.hash_column(column); dataset.hash_column(primary_key, column); end
-    def self.join(*args); dataset.join(*args); end
-    def self.lock(mode, &block); dataset.lock(mode, &block); end
+    # def self.each(&block); dataset.each(&block); end
+    # def self.all; dataset.all; end
+    # def self.filter(*arg, &block); dataset.filter(*arg, &block); end
+    # def self.exclude(*arg, &block); dataset.exclude(*arg, &block); end
+    # def self.order(*arg); dataset.order(*arg); end
+    # def self.first(*arg); dataset.first(*arg); end
+    # def self.count; dataset.count; end
+    # def self.map(*arg, &block); dataset.map(*arg, &block); end
+    # def self.hash_column(column); dataset.hash_column(primary_key, column); end
+    # def self.join(*args); dataset.join(*args); end
+    # def self.lock(mode, &block); dataset.lock(mode, &block); end
     def self.destroy_all
       has_hooks?(:before_destroy) ? dataset.destroy : dataset.delete
     end
@@ -233,7 +233,7 @@ module Sequel
     FILTER_BY_REGEXP = /^filter_by_(.*)/.freeze
     ALL_BY_REGEXP = /^all_by_(.*)/.freeze
     
-    def self.method_missing(m, *args)
+    def self.method_missing(m, *args, &block)
       Thread.exclusive do
         method_name = m.to_s
         if method_name =~ FIND_BY_REGEXP
@@ -245,9 +245,11 @@ module Sequel
         elsif method_name =~ ALL_BY_REGEXP
           c = $1
           meta_def(method_name) {|arg| filter(c => arg).all}
+        elsif dataset.respond_to?(m)
+          instance_eval("def #{m}(*args, &block); dataset.#{m}(*args, &block); end")
         end
       end
-      respond_to?(m) ? send(m, *args) : super(m, *args)
+      respond_to?(m) ? send(m, *args, &block) : super(m, *args)
     end
     
     def db; self.class.db; end
@@ -259,13 +261,17 @@ module Sequel
     WRITE_ATTR_REGEXP = /(.*)=$/.freeze
 
     def method_missing(m, value = nil)
-      if m.to_s =~ WRITE_ATTR_REGEXP
-        self[$1.to_sym] = value
-      else
-        self[m]
-      end
+      write = m.to_s =~ WRITE_ATTR_REGEXP
+      att = write ? $1.to_sym : m
+      # raise unless the att is recognized or this is a new unaved record
+      super unless @values.include?(att) || !@pkey
+      
+      write ? (self[att] = value) : self[att]
     end
     
+    def each(&block); @values.each(&block); end
+    def keys; @values.keys; end
+    
     def id; @values[:id]; end
     
     def save

data/lib/sequel/odbc.rb

@@ -80,7 +80,7 @@ module Sequel
         # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
         case v
         when ::ODBC::TimeStamp
-          Time.gm(v.year, v.month, v.day, v.hour, v.minute, v.second)
+          DateTime.new(v.year, v.month, v.day, v.hour, v.minute, v.second)
         when ::ODBC::Time
           DateTime.now
           Time.gm(now.year, now.month, now.day, v.hour, v.minute, v.second)

data/lib/sequel/pretty_table.rb

@@ -23,9 +23,9 @@ module Sequel
         sizes[c.to_sym] = s if s > sizes[c.to_sym]
       end
       records.each do |r|
-        r.each do |k, v|
-          s = v.to_s.size
-          sizes[k.to_sym] = s if s > sizes[k.to_sym]
+        columns.each do |c|
+          s = r[c].to_s.size
+          sizes[c.to_sym] = s if s > sizes[c.to_sym]
         end
       end
       sizes

data/lib/sequel/sqlite.rb

@@ -11,7 +11,10 @@ module Sequel
       set_adapter_scheme :sqlite
     
       def connect
-        db = SQLite3::Database.new(@opts[:database])
+        if @opts[:database].empty?
+          @opts[:database] = ':memory:'
+        end
+        db = ::SQLite3::Database.new(@opts[:database])
         db.type_translation = true
         db
       end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2007-05-26 00:00:00 +03:00
+  version: 0.1.6
+date: 2007-06-01 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -33,7 +33,6 @@ files:
 - README
 - Rakefile
 - bin/sequel
-- doc/rdoc
 - lib/sequel
 - lib/sequel.rb
 - lib/sequel/connection_pool.rb