sequel 0.4.5 → 0.5

data/lib/sequel/model/relations.rb

@@ -1,107 +0,0 @@
-module Sequel
-  class Model
-    ID_POSTFIX = '_id'.freeze
-    
-    # Creates a 1-1 relationship by defining an association method, e.g.:
-    # 
-    #   class Session < Sequel::Model(:sessions)
-    #   end
-    #
-    #   class Node < Sequel::Model(:nodes)
-    #     one_to_one :producer, :from => Session
-    #     # which is equivalent to
-    #     def producer
-    #       Session[producer_id] if producer_id
-    #     end
-    #   end
-    #
-    # You can also set the foreign key explicitly by including a :key option:
-    #
-    #   one_to_one :producer, :from => Session, :key => :producer_id
-    #
-    # The one_to_one macro also creates a setter, which accepts nil, a hash or
-    # a model instance, e.g.:
-    #
-    #   p = Producer[1234]
-    #   node = Node[:path => '/']
-    #   node.producer = p
-    #   node.producer_id #=> 1234
-    #
-    def self.one_to_one(name, opts)
-      # deprecation
-      if opts[:class]
-        warn "The :class option has been deprecated. Please use :from instead."
-        opts[:from] = opts[:class]
-      end
-      
-      from = opts[:from]
-      from || (raise Error, "No association source defined (use :from option)")
-      key = opts[:key] || (name.to_s + ID_POSTFIX).to_sym
-      
-      setter_name = "#{name}=".to_sym
-      
-      case from
-      when Symbol
-        class_def(name) {(k = @values[key]) ? db[from][:id => k] : nil}
-      when Sequel::Dataset
-        class_def(name) {(k = @values[key]) ? from[:id => k] : nil}
-      else
-        class_def(name) {(k = @values[key]) ? from[k] : nil}
-      end
-      class_def(setter_name) do |v|
-        case v
-        when nil
-          set(key => nil)
-        when Sequel::Model
-          set(key => v.pk)
-        when Hash
-          set(key => v[:id])
-        end
-      end
-
-      # define_method name, &eval(ONE_TO_ONE_PROC % [key, from])
-    end
-  
-    # Creates a 1-N relationship by defining an association method, e.g.:
-    # 
-    #   class Book < Sequel::Model(:books)
-    #   end
-    #
-    #   class Author < Sequel::Model(:authors)
-    #     one_to_many :books, :from => Book
-    #     # which is equivalent to
-    #     def books
-    #       Book.filter(:author_id => id)
-    #     end
-    #   end
-    #
-    # You can also set the foreign key explicitly by including a :key option:
-    #
-    #   one_to_many :books, :from => Book, :key => :author_id
-    #
-    def self.one_to_many(name, opts)
-      # deprecation
-      if opts[:class]
-        warn "The :class option has been deprecated. Please use :from instead."
-        opts[:from] = opts[:class]
-      end
-      # deprecation
-      if opts[:on]
-        warn "The :on option has been deprecated. Please use :key instead."
-        opts[:key] = opts[:on]
-      end
-      
-      
-      from = opts[:from]
-      from || (raise Error, "No association source defined (use :from option)")
-      key = opts[:key] || (self.to_s + ID_POSTFIX).to_sym
-      
-      case from
-      when Symbol
-        class_def(name) {db[from].filter(key => pk)}
-      else
-        class_def(name) {from.filter(key => pk)}
-      end
-    end
-  end
-end

data/lib/sequel/model/schema.rb

@@ -1,52 +0,0 @@
-module Sequel
-  class Model
-    # Defines a table schema (see Schema::Generator for more information).
-    #
-    # This is only needed if you want to use the create_table or drop_table
-    # methods.
-    def self.set_schema(name = nil, &block)
-      name ? set_dataset(db[name]) : name = table_name
-      @schema = Schema::Generator.new(db, &block)
-      if @schema.primary_key_name
-        set_primary_key @schema.primary_key_name
-      end
-    end
-    
-    # Returns table schema for direct descendant of Model.
-    def self.schema
-      @schema || ((superclass != Model) && (superclass.schema))
-    end
-
-    # Returns name of table.
-    def self.table_name
-      dataset.opts[:from].first
-    end
-    
-    # Returns true if table exists, false otherwise.
-    def self.table_exists?
-      db.table_exists?(table_name)
-    end
-    
-    # Creates table.
-    def self.create_table
-      db.create_table_sql_list(table_name, *schema.create_info).each {|s| db << s} 
-    end
-    
-    # Drops table.
-    def self.drop_table
-      db.execute db.drop_table_sql(table_name)
-    end
-    
-    # Like create_table but invokes drop_table when table_exists? is true.
-    def self.create_table!
-      drop_table if table_exists?
-      create_table
-    end
-    
-    # Deprecated, use create_table! instead.
-    def self.recreate_table
-      warn "Model.recreate_table is deprecated. Please use Model.create_table! instead."
-      create_table!
-    end
-  end
-end

data/lib/sequel/model/validations.rb

@@ -1,117 +0,0 @@
-module Sequel
-  class Model
-    # =Basic Sequel Validations
-    #
-    # Sequel validations are based on the Validatable gem http://validatable.rubyforge.org/
-    # 
-    # To assign default validations to a sequel model:
-    # 
-    # class MyModel < SequelModel(:items)
-    #   validates do
-    #     format_of...
-    #     presence_of...
-    #     acceptance_of...
-    #     confirmation_of...
-    #     length_of...
-    #     true_for...
-    #     numericality_of...
-    #     format_of...
-    #     validates_base...
-    #     validates_each...
-    #   end
-    # end
-    #
-    # You may also perform the usual 'longhand' way to assign default model validates 
-    # directly within the model class itself:
-    #
-    #   class MyModel < SequelModel(:items)
-    #     validates_format_of...
-    #     validates_presence_of...
-    #     validates_acceptance_of...
-    #     validates_confirmation_of...
-    #     validates_length_of...
-    #     validates_true_for...
-    #     validates_numericality_of...
-    #     validates_format_of...
-    #     validates_base...
-    #     validates_each...
-    #   end
-    #
-    # Each validation allows for arguments:
-    #   TODO: fill the argument options in here
-    #
-    # =Advanced Sequel Validations
-    #
-    # TODO: verify that advanced validates work as stated (aka write specs)
-    # NOTE: experimental
-    #
-    #  To store validates for conditional usage simply specify a name with which to store them
-    #    class User < Sequel::Model
-    #
-    #      # This set of validates becomes stored as :default and gets injected into the model.
-    #      validates do
-    #        # standard validates calls
-    #      end
-    #      
-    #      validates(:registration) do
-    #        # user registration specific validates 
-    #      end
-    #      
-    #      validates(:promotion) do
-    #        # user promotion validates
-    #      end
-    #
-    #    end
-    #
-    # To use the above validates:
-    #
-    #   @user.valid?                # Runs the default validations only.
-    #   @user.valid?(:registration) # Runs both default and registration validations
-    #   @user.valid?(:promotion)    # Runs both default and promotion validations
-    #
-    # You may determine whether the model has validates via:
-    #
-    #   has_validations? # will return true / false based on existence of validations on the model.
-    #
-    # You may also retrieve the validations block if needed:
-    #
-    #   validates(:registration) # returns the registration validation block.
-    #
-    # validates() method parameters:
-    #   a validations block - runs the validations block on the model & stores as :default
-    #   a name and a validations block - stores the block under the name
-    #   a name - returns a stored block of that name or nil
-    #   nothing - returns true / false based on if validations exist for the model.
-    #
-    module Validations
-      class Generator
-        def initialize(model_class ,&block)
-          @model_class = model_class
-          instance_eval(&block)
-        end
-
-        def method_missing(method, *args)
-          method = :"validates_#{method}"
-          @model_class.send(method, *args)
-        end
-      end
-    end
-    
-    begin
-      require "validatable"
-      include ::Validatable
-      def self.validates(&block)
-        Validations::Generator.new(self, &block)
-      end
-      # return true if there are validations stored, false otherwise
-      def self.has_validations?
-        validations.length > 0 ? true : false
-      end
-    rescue LoadError
-      STDERR.puts <<-MESSAGE
-      Install the validatable gem in order to use Sequel Model validations
-      If you would like model validations to work, install the validatable gem
-      MESSAGE
-    end
-  end
-end

data/spec/model/base_spec.rb

@@ -1,148 +0,0 @@
-describe "Model attribute setters" do
-
-  before(:each) do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
-    end
-  end
-
-  it "should mark the column value as changed" do
-    o = @c.new
-    o.changed_columns.should == []
-
-    o.x = 2
-    o.changed_columns.should == [:x]
-
-    o.y = 3
-    o.changed_columns.should == [:x, :y]
-
-    o.changed_columns.clear
-
-    o[:x] = 2
-    o.changed_columns.should == [:x]
-
-    o[:y] = 3
-    o.changed_columns.should == [:x, :y]
-  end
-
-end
-
-describe "Model#serialize" do
-
-  before(:each) do
-    MODEL_DB.reset
-  end
-
-  it "should translate values to YAML when creating records" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      serialize :abc
-    end
-
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('--- 1\n')", \
-      "INSERT INTO items (abc) VALUES ('--- hello\n')", \
-    ]
-  end
-
-  it "should support calling after the class is defined" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-    end
-
-    @c.serialize :def
-
-    @c.create(:def => 1)
-    @c.create(:def => "hello")
-
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (def) VALUES ('--- 1\n')", \
-      "INSERT INTO items (def) VALUES ('--- hello\n')", \
-    ]
-  end
-
-  it "should support using the Marshal format" do
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-      serialize :abc, :format => :marshal
-    end
-
-    @c.create(:abc => 1)
-    @c.create(:abc => "hello")
-
-    MODEL_DB.sqls.should == [ \
-      "INSERT INTO items (abc) VALUES ('\004\bi\006')", \
-      "INSERT INTO items (abc) VALUES ('\004\b\"\nhello')", \
-    ]
-  end
-
-  it "should translate values to and from YAML using accessor methods" do
-    @c = Class.new(Sequel::Model(:items)) do
-      serialize :abc, :def
-    end
-
-    ds = @c.dataset
-    ds.extend(Module.new {
-      attr_accessor :raw
-
-      def fetch_rows(sql, &block)
-        block.call(@raw)
-      end
-
-      @@sqls = nil
-
-      def insert(*args)
-        @@sqls = insert_sql(*args)
-      end
-
-      def update(*args)
-        @@sqls = update_sql(*args)
-      end
-
-      def sqls
-        @@sqls
-      end
-
-      def columns
-        [:id, :abc, :def]
-      end
-    }
-    )
-
-    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
-    o = @c.first
-    o.id.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-
-    o.set(:abc => 23)
-    ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)"
-
-    ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
-    o = @c.create(:abc => [1, 2, 3])
-    ds.sqls.should == "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"
-  end
-
-end
-
-describe Sequel::Model, "super_dataset" do
-  
-  before(:each) do
-    MODEL_DB.reset
-    class SubClass < Sequel::Model(:items) ; end
-  end
-  
-  it "should call the superclass's dataset" do
-    SubClass.should_receive(:superclass).exactly(3).times.and_return(Sequel::Model(:items))
-    Sequel::Model(:items).should_receive(:dataset)
-    SubClass.super_dataset
-  end
-
-end

data/spec/model/caching_spec.rb

@@ -1,148 +0,0 @@
-describe Sequel::Model, "caching" do
-
-  before(:each) do
-    MODEL_DB.reset
-    
-    @cache_class = Class.new(Hash) do
-      attr_accessor :ttl
-      def set(k, v, ttl); self[k] = v; @ttl = ttl; end
-      def get(k); self[k]; end
-    end
-    cache = @cache_class.new
-    @cache = cache
-    
-    @c = Class.new(Sequel::Model(:items)) do
-      set_cache cache
-      
-      def self.columns
-        [:name, :id]
-      end
-    end
-    
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
-    @dataset = @c.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-      
-      def update(values)
-        $sqls << update_sql(values)
-        $cache_dataset_row.merge!(values)
-      end
-      
-      def delete
-        $sqls << delete_sql
-      end
-    })
-  end
-  
-  it "should set the model's cache store" do
-    @c.cache_store.should be(@cache)
-  end
-  
-  it "should have a default ttl of 3600" do
-    @c.cache_ttl.should == 3600
-  end
-  
-  it "should take a ttl option" do
-    @c.set_cache @cache, :ttl => 1234
-    @c.cache_ttl.should == 1234
-  end
-  
-  it "should offer a set_cache_ttl method for setting the ttl" do
-    @c.cache_ttl.should == 3600
-    @c.set_cache_ttl 1234
-    @c.cache_ttl.should == 1234
-  end
-  
-  it "should generate a cache key appropriate to the class" do
-    m = @c.new
-    m.values[:id] = 1
-    m.cache_key.should == "#{m.class}:1"
-    
-    # custom primary key
-    @c.set_primary_key :ttt
-    m = @c.new
-    m.values[:ttt] = 333
-    m.cache_key.should == "#{m.class}:333"
-    
-    # composite primary key
-    @c.set_primary_key [:a, :b, :c]
-    m = @c.new
-    m.values[:a] = 123
-    m.values[:c] = 456
-    m.values[:b] = 789
-    m.cache_key.should == "#{m.class}:123,789,456"
-  end
-  
-  it "should raise error if attempting to generate cache_key and primary key value is null" do
-    m = @c.new
-    proc {m.cache_key}.should raise_error(Sequel::Error)
-    
-    m.values[:id] = 1
-    proc {m.cache_key}.should_not raise_error(Sequel::Error)
-  end
-  
-  it "should set the cache when reading from the database" do
-    $sqls.should == []
-    @cache.should be_empty
-    
-    m = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m.values.should == $cache_dataset_row
-    @cache[m.cache_key].should == m
-    
-    # read from cache
-    m2 = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m2.should == m
-    m2.values.should == $cache_dataset_row
-  end
-  
-  it "should delete the cache when writing to the database" do
-    # fill the cache
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    
-    m.set(:name => 'tutu')
-    @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
-    
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    m.name = 'hey'
-    m.save
-    @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey', id = 1 WHERE (id = 1)"
-  end
-  
-  it "should delete the cache when deleting the record" do
-    # fill the cache
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    
-    m.delete
-    @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
-  end
-  
-  it "should support #[] as a shortcut to #find with hash" do
-    m = @c[:id => 3]
-    @cache[m.cache_key].should be_nil
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
-    
-    m = @c[1]
-    @cache[m.cache_key].should == m
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-    
-    @c[:id => 4]
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
-  end
-  
-end