sequel_model 0.1

data/lib/sequel_model/relations.rb

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,117 @@
+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/base_spec.rb

@@ -0,0 +1,150 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+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/caching_spec.rb

@@ -0,0 +1,150 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+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