sequel 0.0.1

data/lib/sequel/sqlite.rb

@@ -0,0 +1,112 @@
+require 'sqlite3'
+require 'metaid'
+
+module Sequel
+  module SQLite
+    class Database < Sequel::Database
+      set_adapter_scheme :sqlite
+      attr_reader :pool
+    
+      def initialize(opts = {})
+        super
+        @pool = ConnectionPool.new(@opts[:max_connections] || 4) do
+          db = SQLite3::Database.new(@opts[:database])
+          db.type_translation = true
+          db
+        end
+      end
+    
+      def dataset(opts = nil)
+        SQLite::Dataset.new(self, opts)
+      end
+    
+      def tables
+        # return a list of tables
+      end
+    
+      def execute(sql)
+        @pool.hold {|conn| conn.execute(sql)}
+      end
+      
+      def execute_insert(sql)
+        @pool.hold {|conn| conn.execute(sql); conn.last_insert_row_id}
+      end
+      
+      def single_value(sql)
+        @pool.hold {|conn| conn.get_first_value(sql)}
+      end
+      
+      def result_set(sql, record_class, &block)
+        @pool.hold do |conn|
+          conn.query(sql) do |result|
+            columns = result.columns
+            column_count = columns.size
+            result.each do |values|
+              row = {}
+              column_count.times {|i| row[columns[i].to_sym] = values[i]}
+              block.call(record_class ? record_class.new(row) : row)
+            end
+          end
+        end
+      end
+      
+      def synchronize(&block)
+        @pool.hold(&block)
+      end
+    
+      def transaction(&block)
+        @pool.hold {|conn| conn.transaction(&block)}
+      end
+
+      def table_exists?(name)
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def each(opts = nil, &block)
+        @db.result_set(select_sql(opts), @record_class, &block)
+        self
+      end
+    
+      LIMIT_1 = {:limit => 1}.freeze
+    
+      def first(opts = nil)
+        opts = opts ? opts.merge(LIMIT_1) : LIMIT_1
+        @db.result_set(select_sql(opts), @record_class) {|r| return r}
+      end
+    
+      def last(opts = nil)
+        raise RuntimeError, 'No order specified' unless
+          @opts[:order] || (opts && opts[:order])
+      
+        opts = {:order => reverse_order(@opts[:order])}.
+          merge(opts ? opts.merge(LIMIT_1) : LIMIT_1)
+        @db.result_set(select_sql(opts), @record_class) {|r| return r}
+      end
+      
+      def count(opts = nil)
+        @db.single_value(count_sql(opts)).to_i
+      end
+    
+      def insert(values = nil, opts = nil)
+        @db.synchronize do
+          @db.execute_insert insert_sql(values, opts)
+        end
+      end
+    
+      def update(values, opts = nil)
+        @db.synchronize do
+          @db.execute update_sql(values, opts)
+        end
+        self
+      end
+    
+      def delete(opts = nil)
+        @db.synchronize do
+          @db.execute delete_sql(opts)
+        end
+        self
+      end
+    end
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+
+class Sequel::Database
+  attr_accessor :opts
+end
+
+context "A new Database" do
+  specify "should accept options and store them in @opts" do
+    opts = :my_options
+    Sequel::Database.new(opts).opts.should_be opts
+  end
+  
+  specify "should set opts to empty hash if not specified" do
+    Sequel::Database.new.opts.should == {}
+  end
+end
+

data/spec/dataset_spec.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+class sequel::Dataset
+  attr_accessor :db, :opts
+end
+
+context "The Dataset Class" do
+  specify "should include the Enumerable mix-in" do
+    Sequel::Dataset.included_modules.should_include Enumerable
+  end
+end
+
+context "A new Dataset instance" do
+  specify "should store db and opts in @db and @opts" do
+    db = "my db"
+    opts = [1, 2, 3, 4]
+    
+    d = Sequel::Dataset.new(db, opts)
+    d.db.should_be db
+    d.opts.should_be opts
+  end
+  
+  specify "should set opts to empty hash if ommited" do
+    Sequel::Dataset.new(:db).opts.should == {}
+  end
+end
+
+context "Dataset#dup_merge" do
+  specify "should create a new instance of the same class with merged opts" do
+    subclass = Class.new(Sequel::Dataset)
+    db = "my db"
+    orig = subclass.new(db, {1 => 2, 3 => 4})
+    dup = orig.dup_merge({3 => 5})
+    
+    dup.class.should_be subclass
+    dup.opts.should == {1 => 2, 3 => 5}
+    dup.db.should_be db
+  end
+end
+
+context "Dataset#field_name" do
+  setup {@d = Sequel::Dataset.new(:db)}
+
+  specify "should return the argument as is if not a symbol" do
+    @d.field_name(nil).should == nil
+    @d.field_name(1).should == 1
+    @d.field_name('field').should == 'field'
+  end
+  
+  specify "should parse fields with underscore without change" do
+    @d.field_name(:node_id).should == 'node_id'
+  end
+  
+  specify "should parse double-underscore as dot-notation" do
+    @d.field_name(:posts__id).should == 'posts.id'
+  end
+  
+  specify "should parse triple-underscore as AS notation" do
+    @d.field_name(:posts__id___pid).should == 'posts.id AS pid'
+  end
+end
+
+context "Dataset#field_list" do
+  setup {@d = Sequel::Dataset.new(:db)}
+
+  specify "should return the sql wildcard if an empty array is specified" do
+    @d.field_list([]).should == '*'
+  end
+  
+  specify "should return comma-separated field list if an array is passed" do
+    @d.field_list([:a, :b]).should == 'a, b'
+  end
+  
+  specify "should return the argument as is if not an array" do
+    @d.field_list(nil).should_be_nil
+    @d.field_list(23).should_be 23
+    @d.field_list("wowie zowie").should == "wowie zowie"
+  end
+  
+  specify "should parse field names using #field_name" do
+    @d.field_list([:posts__author_id, :authors__name]).should ==
+      'posts.author_id, authors.name'
+    
+    @d.field_list([:posts__id___pid, :authors__name___aname]).should ==
+      'posts.id AS pid, authors.name AS aname'
+  end
+end
+
+context "Dataset#source_list" do
+  setup {@d = Sequel::Dataset.new(:db)}
+
+  specify "should return the argument if not an array or hash" do
+    @d.source_list(nil).should_be_nil
+    @d.source_list(1).should == 1
+    @d.source_list('hello').should == 'hello'
+    @d.source_list(:symbol).should == :symbol
+  end
+  
+  specify "should return comma-separated value if an array is specified" do
+    @d.source_list([1, 2, 3]).should == '1, 2, 3'
+  end
+end
+
+context "Dataset DSL: " do
+  specify "#form should create a duplicate dataset with the source argument merged" do
+    subclass = Class.new(Sequel::Dataset)
+    d1 = subclass.new(:db, {:select => '*'})
+    
+    d2 = d1.from(:posts)
+    d2.class.should_be subclass
+    d2.opts[:select].should == '*'
+    d2.opts[:from].should == :posts
+  end 
+
+  specify "#select should create a duplicate dataset with the select argument merged" do
+    subclass = Class.new(Sequel::Dataset)
+    d1 = subclass.new(:db, {:from => :posts})
+    
+    d2 = d1.select(:id, :name)
+    d2.class.should_be subclass
+    d2.opts[:from].should == :posts
+    d2.opts[:select].should == [:id, :name]
+  end 
+end

data/spec/postgres_spec.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+require File.join(File.dirname(__FILE__), '../lib/sequel/postgres')
+
+context "A new Postgres::Database" do
+end
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: sequel
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-03-05 00:00:00 +02:00
+summary: ORM framework for Ruby.
+require_paths: 
+- lib
+email: ciconia@gmail.com
+homepage: http://code.google.com/p/ruby-sequel/
+rubyforge_project: 
+description: ORM framework for Ruby.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Sharon Rosner
+files: 
+- COPYING
+- README
+- Rakefile
+- doc/rdoc
+- spec/database_spec.rb
+- spec/dataset_spec.rb
+- spec/postgres_spec.rb
+- lib/sequel
+- lib/sequel.rb
+- lib/sequel/dataset.rb
+- lib/sequel/model.rb
+- lib/sequel/postgres.rb
+- lib/sequel/schema.rb
+- lib/sequel/sqlite.rb
+- lib/sequel/connection_pool.rb
+- lib/sequel/database.rb
+- lib/sequel/core_ext.rb
+- CHANGELOG
+test_files: []
+
+rdoc_options: 
+- --quiet
+- --title
+- Sequel Documentation
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)\/
+- --exclude
+- lib/sequel.rb
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- COPYING
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: