sequel_model 0.3 → 0.3.1

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== 0.3.1
+
+* Changed Model.dataset to use inflector to pluralize the class name into the table name. Works in similar fashion to table names in AR or DM.
+
 === 0.3 (2008-01-18)
 
 * Implemented Validatable::Errors class.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_model"
-VERS = "0.3"
+VERS = "0.3.1"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 

data/lib/sequel_model/base.rb

@@ -19,12 +19,13 @@ module Sequel
 
     # Returns the dataset associated with the Model class.
     def self.dataset
-      (@dataset ||= super_dataset) ||
+      @dataset ||= super_dataset ||
+        (!(n = name).empty? && db[n.underscore.pluralize.to_sym]) ||
         (raise Error, "No dataset associated with #{self}")
     end
     
     def self.super_dataset # :nodoc:
-      superclass.dataset if superclass and superclass.respond_to? :dataset
+      superclass.dataset if (superclass != Sequel::Model) && superclass.respond_to?(:dataset)
     end
     
     # Returns the columns in the result set in their original order.
@@ -79,8 +80,8 @@ module Sequel
   # Makes given dataset inherited.
   #
   # === Example:
-  #   class Comment < Sequel::Model(:comments)
-  #     table_name # => :comments
+  #   class Comment < Sequel::Model(:something)
+  #     table_name # => :something
   #
   #     # ...
   #

data/lib/sequel_model/record.rb

@@ -53,12 +53,12 @@ module Sequel
     # Sets primary key, regular and composite are possible.
     #
     # == Example:
-    #   class Tagging < Sequel::Model(:taggins)
+    #   class Tagging < Sequel::Model
     #     # composite key
     #     set_primary_key :taggable_id, :tag_id
     #   end
     #
-    #   class Person < Sequel::Model(:person)
+    #   class Person < Sequel::Model
     #     # regular key
     #     set_primary_key :person_id
     #   end

data/lib/sequel_model/relations.rb

@@ -4,10 +4,10 @@ module Sequel
     
     # Creates a 1-1 relationship by defining an association method, e.g.:
     # 
-    #   class Session < Sequel::Model(:sessions)
+    #   class Session < Sequel::Model
     #   end
     #
-    #   class Node < Sequel::Model(:nodes)
+    #   class Node < Sequel::Model
     #     one_to_one :producer, :from => Session
     #     # which is equivalent to
     #     def producer
@@ -58,10 +58,10 @@ module Sequel
   
     # Creates a 1-N relationship by defining an association method, e.g.:
     # 
-    #   class Book < Sequel::Model(:books)
+    #   class Book < Sequel::Model
     #   end
     #
-    #   class Author < Sequel::Model(:authors)
+    #   class Author < Sequel::Model
     #     one_to_many :books, :from => Book
     #     # which is equivalent to
     #     def books
@@ -92,7 +92,7 @@ module Sequel
     # Database modelling is generally done with an ER (Entity Relationship) diagram.
     # Shouldn't ORM's facilitate simlilar specification?
 
-    #   class Post < Sequel::Model(:users)
+    #   class Post < Sequel::Model
     #     relationships do
     #       # Specify the relationships that exist with the User model (users table)
     #       # These relationships are precisely the ER diagram connecting arrows.
@@ -111,7 +111,7 @@ module Sequel
     # ?parameters may be :zero, :one, :many which specifies the cardinality of the connection
 
     # Example:
-    #   class Post < Sequel::Model(:users)
+    #   class Post < Sequel::Model
     #     relationships do
     #       has :one,  :blog, :required => true # blog_id field, cannot be null
     #       has :one,  :account # account_id field

data/lib/sequel_model/relationships.rb

@@ -0,0 +1,233 @@
+# = Sequel Relationships
+# Database modelling is generally done with an ER (Entity Relationship) diagram.
+# Shouldn't ORM's facilitate simlilar specification?
+
+# class Post < Sequel::Model
+#   relationships do
+#     # Specify the relationships that exist with the User model (users table)
+#     # These relationships are precisely the ER diagram connecting arrows.
+#   end
+# end
+
+#
+# = Relationships 
+#
+# are specifications of the ends of the ER diagrams connectors that are touching
+# the current model.
+#
+# one_to_one,   has_one
+# many_to_one,  belongs_to
+# many_to_many, has_many
+
+# ?parameters may be :zero, :one, :many which specifies the cardinality of the connection
+
+# Example:
+# class Post < Sequel::Model
+#   relationships do
+#     has :one,  :blog, :required => true, :normalized => false # uses a blog_id field, which cannot be null, in the Post model
+#     has :one,  :account # uses a join table called accounts_posts to link the post with it's account.
+#     has :many, :comments # uses a comments_posts join table
+#     has :many, :authors, :required => true  # authors_posts join table, requires at least one author
+#   end
+# end
+# 
+#
+# Relationship API Details
+#
+
+#
+# == belongs_to
+#
+
+# Defines an blog and blog= method
+#   belongs_to :blog
+
+# Same, but uses "b_id" as the blog's id field.
+#   belongs_to :blog, :key => :b_id
+
+#   has_many   :comments
+# * Defines comments method which will query the join table appropriately.
+# * Checks to see if a "comments_posts" join table exists (alphabetical order)
+# ** If it does not exist, will create the join table. 
+# ** If options are passed in these will be used to further define the join table.
+
+
+# Benefits:
+# * Normalized DB
+# * Easy to define join objects
+# * Efficient queries, database gets to use indexed fields (pkeys) instead of a string field and an id.
+# 
+# For example, polymorphic associations now become:
+# [user]      1-* [addresses_users]     *-1 [addresses]
+# [companies] 1-* [addresses_companies] *-1 [addresses]
+# [clients]   1-* [addresses_clients]   *-1 [addresses]
+# it is automatically polymorphic by specifying the has relationship inside the 2User and Company tables to addresses. Addresses themselves don't care. so we have by default polymorphism. 
+# If you need to talk about a 'Company Address' then you can subclass, CompanyAddress < Address and do has :many, :company_addresses
+
+module Sequel
+
+  class Model
+
+    module Relationships
+      class Generator
+        def initialize(model_class, &block)
+          @model_class = model_class
+          instance_eval(&block)
+        end
+
+        def method_missing(method, *args)
+          @model_class.send(method, *args)
+        end
+      end
+    end
+
+    class << self
+      cattr_reader :model_relationships
+      @@model_relationships = []
+
+      def relationship_exists?(arity,relation)
+        @@model_relationships.detect do |relation|
+          relation[:arity] == arity && 
+          relation[:klass] == relation
+        end
+      end
+
+      # has arity<Symbol>, model<Symbol>
+      # has :one,  :blog, :required => true # blog_id field, cannot be null
+      # has :one,  :account # account_id field
+      # has :many, :comments # comments_posts join table
+      def has(arity, klass, options = {})
+        unless [:one,:many].include? arity
+          raise Sequel::Error, "Arity must be specified {:one, :many}." 
+        end
+
+        #unless const_defined?(klass.to_s.camel_case)
+          #raise Sequel::Error, "#{klass.to_s.camel_case} does not exist"
+        #end
+
+        # Make sure the join table exists
+        auto_create_join_table(klass, options)
+
+        if relationship_exists?(arity, klass)
+          raise Sequel::Error, "The relationship #{self.class.name} has #{arity}, #{klass} is already defined."
+        end
+
+        # Store the relationship
+        @@model_relationships << { 
+          :arity => arity, 
+          :klass => klass, 
+          :options => options 
+        }
+
+        # Define relationship methods
+        after_initialize do
+          define_relationship_method arity, klass, options
+        end
+
+        #unless normalized
+          # :required => true # The relationship must be populated to save
+          # can only be used with normalized => false : 
+        #end
+        # save the relationship
+      end
+      
+      # the proxy methods has_xxx ... , simply pass thru to to has :xxx, ...
+      def has_one(klass, options = {})
+        has :one, klass, options
+      end
+
+      def has_many(klass, options = {})
+        has :many, klass, options
+      end
+
+      def belongs_to(klass, options = {})
+        has :one, klass, options
+      end
+
+      # returns true if exists, false if not
+      def join_table?(first, second)
+        # we still have to test this out      
+        db[join_table(first, second)].table_exists?
+      end
+
+      # TODO: Move this elsewhere? outside relationships?
+      # creates a join table given two table names
+      def create_join_table(first, second)
+        first_key, second_key = "#{first}_id", "#{second}_id"
+        db.create_table join_table(first, second).to_sym do
+          #primary_key [first_key.to_sym, second_key.to_sym]
+          integer first_key, :null => false
+          integer second_key, :null => false
+        end unless join_table?(first, second)
+      end
+
+      def create_join_table!(first, second)
+        db.drop_table join_table(first, second)
+        create_join_table(first, second)
+      end
+
+      def auto_create_join_table!(klass)
+        auto_create_join_table(klass, :force => true)
+      end
+
+      def auto_create_join_table(klass, options = {})
+        first, second = table_name, klass.to_s.pluralize
+        if join_table?(first, second) && options[:force] == true
+          create_join_table!(first, second)
+        else
+          create_join_table(first, second)
+        end
+      end
+
+      # Given two models, it outputs the join table name
+      # which is sorted alphabetically with each table name pluralized
+      # Examples:
+      #   join_table(user, post) #=> :posts_users
+      #   join_table(users, posts) #=> :posts_users
+      def join_table(first, second)
+        first, second = first.to_s.pluralize, second.to_s.pluralize
+        [first, second].sort.join("_").to_sym
+      end
+
+      # relationships do
+      #   ...
+      # end
+      def relationships(&block)
+        Relationships::Generator.new(self, &block)
+      end
+
+      # return true if there are validations stored, false otherwise
+      def has_relationships?
+        model_relationships.length > 0 ? true : false
+      end
+
+      # TODO: figure out what we want to do with these...
+      # "FooBar".snake_case #=> "foo_bar"
+      def snake_case
+        gsub(/\B[A-Z]/, '_\&').downcase
+      end
+
+      # "foo_bar".camel_case #=> "FooBar"
+      def camel_case
+        split('_').map{|e| e.capitalize}.join
+      end
+    end
+
+    # Defines relationship method from the current class to the klass specified
+    def define_relationship_method(arity, relation, options)
+      if arity == :one
+        self.instance_eval "
+          def #{relation}
+            self.db.dataset.left_outer_join(#{relation}, :id => :#{relation.to_s.singularize}_id).limit(1)
+          end
+        "
+      elsif arity == :many
+        self.instance_eval "
+          def #{relation}
+            self.db.dataset.left_outer_join(#{relation}, :id => :#{relation.to_s.singularize}_id)
+          end
+        "
+      end
+    end # define_relationship_method
+  end # Model
+end # Sequel

data/lib/sequel_model.rb

@@ -13,7 +13,7 @@ module Sequel
   # You can also use the shorthand form:
   # 
   #   DB = Sequel('sqlite:/blog.db')
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #   end
   # 
   # === Model instances
@@ -28,7 +28,7 @@ module Sequel
   # 
   # Sequel models allow you to use any column as a primary key, and even composite keys made from multiple columns:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     set_primary_key [:category, :title]
   #   end
   # 
@@ -100,7 +100,7 @@ module Sequel
   # 
   # Hooks are defined by supplying a block:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     after_create do
   #       set(:created_at => Time.now)
   #     end
@@ -128,17 +128,17 @@ module Sequel
   # 
   # The most straightforward way to define an association in a Sequel model is as a regular instance method:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     def author; Author[author_id]; end
   #   end
   # 
-  #   class Author < Sequel::Model(:authors)
+  #   class Author < Sequel::Model
   #     def posts; Post.filter(:author_id => pk); end
   #   end
   # 
   # Sequel also provides two macros to assist with common types of associations. The one_to_one macro is roughly equivalent to ActiveRecord?'s belongs_to macro. It defines both getter and setter methods for the association:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     one_to_one :author, :from => Author
   #   end
   #
@@ -147,7 +147,7 @@ module Sequel
   # 
   # The one_to_many macro is roughly equivalent to ActiveRecord's has_many macro:
   # 
-  #   class Author < Sequel::Model(:authors)
+  #   class Author < Sequel::Model
   #     one_to_many :posts, :from => Post, :key => :author_id
   #   end
   # 
@@ -160,7 +160,7 @@ module Sequel
   #   require 'memcache'
   #   CACHE = MemCache.new 'localhost:11211', :namespace => 'blog'
   # 
-  #   class Author < Sequel::Model(:authors)
+  #   class Author < Sequel::Model
   #     set_cache CACHE, :ttl => 3600
   #   end
   # 
@@ -171,7 +171,7 @@ module Sequel
   # 
   # The obvious way to add table-wide logic is to define class methods to the model class definition. That way you can define subsets of the underlying dataset, change the ordering, or perform actions on multiple records:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     def self.old_posts
   #       filter {:stamp < 30.days.ago}
   #     end
@@ -183,7 +183,7 @@ module Sequel
   # 
   # You can also implement table-wide logic by defining methods on the dataset:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     def dataset.old_posts
   #       filter {:stamp < 30.days.ago}
   #     end
@@ -199,7 +199,7 @@ module Sequel
   # 
   # Sequel models also provide a short hand notation for filters:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     subset(:old_posts) {:stamp < 30.days.ago}
   #     subset :invisible, :visible => false
   #   end
@@ -208,7 +208,7 @@ module Sequel
   # 
   # Model classes can also be used as a place to define your table schema and control it. The schema DSL is exactly the same provided by Sequel::Schema::Generator:
   # 
-  #   class Post < Sequel::Model(:posts)
+  #   class Post < Sequel::Model
   #     set_schema do
   #       primary_key :id
   #       text :title
@@ -230,8 +230,9 @@ module Sequel
 
 end
 
+# TODO: add relationships when complete:
 files = %w[
-  base hooks record schema relations
+  base hooks record schema relations 
   caching plugins validations
 ]
 dir = File.join(File.dirname(__FILE__), "sequel_model")

data/spec/base_spec.rb

@@ -135,8 +135,7 @@ describe "Model#serialize" do
 end
 
 describe Sequel::Model, "super_dataset" do
-  
-  before(:each) do
+  setup do
     MODEL_DB.reset
     class SubClass < Sequel::Model(:items) ; end
   end
@@ -146,5 +145,41 @@ describe Sequel::Model, "super_dataset" do
     Sequel::Model(:items).should_receive(:dataset)
     SubClass.super_dataset
   end
+end
 
+describe Sequel::Model, "dataset" do
+  setup do
+    @a = Class.new(Sequel::Model(:items))
+    @b = Class.new(Sequel::Model)
+    
+    class Elephant < Sequel::Model(:ele1)
+    end
+    
+    class Maggot < Sequel::Model
+    end
+
+    class ShoeSize < Sequel::Model
+    end
+    
+    class BootSize < ShoeSize
+    end
+  end
+  
+  specify "should default to the plural of the class name" do
+    Maggot.dataset.sql.should == 'SELECT * FROM maggots'
+    ShoeSize.dataset.sql.should == 'SELECT * FROM shoe_sizes'
+  end
+  
+  specify "should return the dataset for the superclass if available" do
+    BootSize.dataset.sql.should == 'SELECT * FROM shoe_sizes'
+  end
+  
+  specify "should return the correct dataset if set explicitly" do
+    Elephant.dataset.sql.should == 'SELECT * FROM ele1'
+    @a.dataset.sql.should == 'SELECT * FROM items'
+  end
+  
+  specify "should raise if no dataset is explicitly set and the class is anonymous" do
+    proc {@b.dataset}.should raise_error(Sequel::Error)
+  end
 end

data/spec/relations_spec.rb

@@ -93,11 +93,6 @@ describe Sequel::Model, "one_to_one" do
     d.values.should == {:id => 1, :parent_id => 6677}
     $sqls.last.should == "UPDATE nodes SET parent_id = 6677 WHERE (id = 1)"
   end
-
-  it "should warn with a depreciation notice if :class option was used" do
-    pending("write this spec")
-  end
-
 end
 
 describe Sequel::Model, "one_to_many" do
@@ -138,13 +133,4 @@ describe Sequel::Model, "one_to_many" do
     a.should be_a_kind_of(Sequel::Dataset)
     a.sql.should == 'SELECT * FROM abc WHERE (node_id = 1234)'
   end
-
-  it "should warn with a depreciation notice if :class option was used" do
-    pending("write this spec")
-  end
-
-  it "should warn with a depreciation notice if :on option was used" do
-    pending("write this spec")
-  end
-
 end

data/spec/relationships_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+__END__
+
+describe Sequel::Model::Relationships, "has :one" do
+end
+
+describe Sequel::Model::Relationships, "has :many" do
+end
+
+describe Sequel::Model::Relationships, "belongs_to" do
+end

data/spec/validations_spec.rb

@@ -293,7 +293,7 @@ end
 describe Sequel::Model, "Validations" do
 
   before(:all) do
-    class Person < Sequel::Model(:people)
+    class Person < Sequel::Model
       def columns
         [:id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms]
       end
@@ -302,19 +302,19 @@ describe Sequel::Model, "Validations" do
     class Smurf < Person
     end
     
-    class Cow < Sequel::Model(:cows)
+    class Cow < Sequel::Model
       def columns
         [:id, :name, :got_milk]
       end
     end
 
-    class User < Sequel::Model(:users)
+    class User < Sequel::Model
       def columns
         [:id, :username, :password]
       end
     end
     
-    class Address < Sequel::Model(:addresses)
+    class Address < Sequel::Model
       def columns
         [:id, :zip_code]
       end
@@ -322,7 +322,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate the acceptance of a column" do
-    class Cow < Sequel::Model(:cows)
+    class Cow < Sequel::Model
       validations.clear
       validates_acceptance_of :got_milk, :accept => 'blah', :allow_nil => false
     end
@@ -336,7 +336,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate the confirmation of a column" do
-    class User < Sequel::Model(:users)      
+    class User < Sequel::Model
       def password_confirmation
         "test"
       end
@@ -354,7 +354,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate format of column" do
-    class Person < Sequel::Model(:people)  
+    class Person < Sequel::Model
       validates_format_of :first_name, :with => /^[a-zA-Z]+$/
     end
 
@@ -369,7 +369,7 @@ describe Sequel::Model, "Validations" do
   # end
 
   it "should validate length of column" do
-    class Person < Sequel::Model(:people)
+    class Person < Sequel::Model
       validations.clear
       validates_length_of :first_name, :maximum => 30
       validates_length_of :last_name, :minimum => 30
@@ -401,7 +401,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate numericality of column" do
-    class Person < Sequel::Model(:people)
+    class Person < Sequel::Model
       validations.clear
       validates_numericality_of :age
     end
@@ -415,7 +415,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should validate the presence of a column" do
-    class Cow < Sequel::Model(:cows)
+    class Cow < Sequel::Model
       validations.clear
       validates_presence_of :name
     end
@@ -429,7 +429,7 @@ describe Sequel::Model, "Validations" do
   end
   
   it "should have a validates block that calls multple validations" do
-    class Person < Sequel::Model(:people)
+    class Person < Sequel::Model
       validations.clear
       validates do
         format_of :first_name, :with => /^[a-zA-Z]+$/
@@ -448,7 +448,7 @@ describe Sequel::Model, "Validations" do
 
   it "should allow 'longhand' validations direcly within the model." do
     lambda {
-      class Person < Sequel::Model(:people)
+      class Person < Sequel::Model
         validations.clear
         validates_length_of :first_name, :maximum => 30
       end
@@ -457,7 +457,7 @@ describe Sequel::Model, "Validations" do
   end
 
   it "should define a has_validations? method which returns true if the model has validations, false otherwise" do
-    class Person < Sequel::Model(:people)
+    class Person < Sequel::Model
       validations.clear
       validates do
         format_of :first_name, :with => /\w+/

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: "0.3"
+  version: 0.3.1
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-18 00:00:00 +02:00
+date: 2008-01-21 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,6 +43,7 @@ files:
 - spec/rcov.opts
 - spec/record_spec.rb
 - spec/relations_spec.rb
+- spec/relationships_spec.rb
 - spec/schema_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -55,6 +56,7 @@ files:
 - lib/sequel_model/pretty_table.rb
 - lib/sequel_model/record.rb
 - lib/sequel_model/relations.rb
+- lib/sequel_model/relationships.rb
 - lib/sequel_model/schema.rb
 - lib/sequel_model/validations.rb
 - lib/sequel_model.rb