friendly 0.3.5 → 0.4.0

data/lib/friendly/boolean.rb

@@ -1,6 +1,10 @@
+require 'friendly/attribute'
+
 module Friendly
+  # placeholder that represents a boolean
+  # since ruby has no boolean superclass
   module Boolean
-    # placeholder that represents a boolean
-    # since ruby has no boolean superclass
   end
 end
+
+Friendly::Attribute.register_type(Friendly::Boolean, 'boolean') { |s| s }

data/lib/friendly/document.rb

@@ -1,4 +1,5 @@
 require 'active_support/inflector'
+require 'friendly/associations'
 
 module Friendly
   module Document
@@ -25,7 +26,9 @@ module Friendly
     end
 
     module ClassMethods
-      attr_writer :storage_proxy, :query_klass, :table_name, :collection_klass
+      attr_writer :storage_proxy, :query_klass, 
+                  :table_name,    :collection_klass,
+                  :scope_proxy,   :association_set
 
       def create_tables!
         storage_proxy.create_tables!
@@ -95,6 +98,95 @@ module Friendly
         @table_name ||= name.pluralize.underscore
       end
 
+      def scope_proxy
+        @scope_proxy ||= ScopeProxy.new(self)
+      end
+
+      # Add a named scope to this Document.
+      #
+      # e.g.
+      #     
+      #     class Post
+      #       indexes     :created_at
+      #       named_scope :recent, :order! => :created_at.desc
+      #     end
+      #
+      # Then, you can access the recent posts with:
+      #
+      #     Post.recent.all
+      # ...or...
+      #     Post.recent.first
+      #
+      # Both #all and #first also take additional parameters:
+      #
+      #     Post.recent.all(:author_id => @author.id)
+      #
+      # Scopes are also chainable. See the README or Friendly::Scope docs for details.
+      #
+      # @param [Symbol] name the name of the scope.
+      # @param [Hash] parameters the query that this named scope will perform.
+      #
+      def named_scope(name, parameters)
+        scope_proxy.add_named(name, parameters)
+      end
+
+      # Returns boolean based on whether the Document has a scope by a particular name.
+      #
+      # @param [Symbol] name The name of the scope in question.
+      #
+      def has_named_scope?(name)
+        scope_proxy.has_named_scope?(name)
+      end
+
+      # Create an ad hoc scope on this Document.
+      #
+      # e.g.
+      #     
+      #     scope = Post.scope(:order! => :created_at)
+      #     scope.all # => [#<Post>, #<Post>]
+      #
+      # @param [Hash] parameters the query parameters to create the scope with.
+      #
+      def scope(parameters)
+        scope_proxy.ad_hoc(parameters)
+      end
+
+      def association_set
+        @association_set ||= Associations::Set.new(self)
+      end
+
+      # Add a has_many association.
+      #
+      # e.g.
+      #
+      #     class Post
+      #       attribute :user_id, Friendly::UUID
+      #       indexes   :user_id
+      #     end
+      #      
+      #     class User
+      #       has_many :posts
+      #     end
+      #     
+      #     @user = User.create
+      #     @post = @user.posts.create
+      #     @user.posts.all == [@post] # => true
+      #
+      # _Note: Make sure that the target model is indexed on the foreign key. If it isn't, querying the association will raise Friendly::MissingIndex._
+      #
+      # Friendly defaults the foreign key to class_name_id just like ActiveRecord.
+      # It also converts the name of the association to the name of the target class just like ActiveRecord does.
+      #
+      # The biggest difference in semantics between Friendly's has_many and active_record's is that Friendly's just returns a Friendly::Scope object. If you want all the associated objects, you have to call #all to get them. You can also use any other Friendly::Scope method.
+      #
+      # @param [Symbol] name The name of the association and plural name of the target class.
+      # @option options [String] :class_name The name of the target class of this association if it is different than the name would imply.
+      # @option options [Symbol] :foreign_key Override the foreign key.
+      # 
+      def has_many(name, options = {})
+        association_set.add(name, options)
+      end
+
       protected
         def query(conditions)
           conditions.is_a?(Query) ? conditions : query_klass.new(conditions)

data/lib/friendly/named_scope.rb

@@ -0,0 +1,17 @@
+require 'friendly/scope'
+
+module Friendly
+  class NamedScope
+    attr_reader :klass, :parameters, :scope_klass
+
+    def initialize(klass, parameters, scope_klass = Scope)
+      @klass       = klass
+      @parameters  = parameters
+      @scope_klass = scope_klass
+    end
+
+    def scope
+      @scope_klass.new(@klass, @parameters)
+    end
+  end
+end

data/lib/friendly/scope.rb

@@ -0,0 +1,100 @@
+module Friendly
+  class Scope
+    attr_reader :klass, :parameters
+
+    def initialize(klass, parameters)
+      @klass      = klass
+      @parameters = parameters
+    end
+
+    # Fetch all documents at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def all(extra_parameters = {})
+      klass.all(params(extra_parameters))
+    end
+
+    # Fetch the first document at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def first(extra_parameters = {})
+      klass.first(params(extra_parameters))
+    end
+
+    # Paginate the documents at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    # @return WillPaginate::Collection
+    #
+    def paginate(extra_parameters = {})
+      klass.paginate(params(extra_parameters))
+    end
+
+    # Build an object at this scope.
+    #
+    #   e.g.
+    #     Post.scope(:name => "James").build.name # => "James"
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def build(extra_parameters = {})
+      klass.new(params_without_modifiers(extra_parameters))
+    end
+
+    # Create an object at this scope.
+    #
+    #   e.g.
+    #     @post = Post.scope(:name => "James").create
+    #     @post.new_record? # => false
+    #     @post.name # => "James"
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def create(extra_parameters = {})
+      klass.create(params_without_modifiers(extra_parameters))
+    end
+
+    # Override #respond_to? so that we can return true when it's another named_scope.
+    #
+    # @override
+    #
+    def respond_to?(method_name, include_private = false)
+      klass.has_named_scope?(method_name) || super
+    end
+
+    # Use method_missing to respond to other named scopes on klass.
+    # 
+    # @override
+    #
+    def method_missing(method_name, *args, &block)
+      respond_to?(method_name) ? chain_with(method_name) : super
+    end
+
+    # Chain with another one of klass's named_scopes.
+    #
+    # @param [Symbol] scope_name The name of the scope to chain with.
+    #
+    def chain_with(scope_name)
+      self + klass.send(scope_name)
+    end
+
+    # Create a new Scope that is the combination of self and other, where other takes priority
+    #
+    # @param [Friendly::Scope] other The scope to merge with.
+    #
+    def +(other_scope)
+      self.class.new(klass, parameters.merge(other_scope.parameters))
+    end
+
+    protected
+      def params(extra)
+        parameters.merge(extra)
+      end
+
+      def params_without_modifiers(extra)
+        params(extra).reject { |k,v| k.to_s =~ /!$/ }
+      end
+  end
+end

data/lib/friendly/scope_proxy.rb

@@ -0,0 +1,45 @@
+require 'friendly/named_scope'
+
+module Friendly
+  class ScopeProxy
+    attr_reader :klass, :scope_klass, :scopes
+
+    def initialize(klass, scope_klass = Scope)
+      @klass       = klass
+      @scope_klass = scope_klass
+      @scopes      = {}
+    end
+
+    def add_named(name, parameters)
+      scopes[name] = parameters
+      add_scope_method_to_klass(name)
+    end
+
+    def get(name)
+      scopes[name]
+    end
+
+    def get_instance(name)
+      scope_klass.new(klass, get(name))
+    end
+
+    def ad_hoc(parameters)
+      scope_klass.new(klass, parameters)
+    end
+
+    def has_named_scope?(name)
+      scopes.has_key?(name)
+    end
+
+    protected
+      def add_scope_method_to_klass(scope_name)
+        klass.class_eval do
+          eval <<-__END__
+            def self.#{scope_name}
+              scope_proxy.get_instance(:#{scope_name})
+            end
+          __END__
+        end
+      end
+  end
+end

data/lib/friendly/sequel_monkey_patches.rb

@@ -32,4 +32,3 @@ module Sequel
     end
   end
 end
-

data/lib/friendly/table_creator.rb

@@ -1,9 +1,10 @@
 module Friendly
   class TableCreator
-    attr_reader :db
+    attr_reader :db, :attr_klass
 
-    def initialize(db = Friendly.db)
-      @db = db
+    def initialize(db = Friendly.db, attr_klass = Friendly::Attribute)
+      @db         = db
+      @attr_klass = attr_klass
     end
 
     def create(table)
@@ -29,10 +30,14 @@ module Friendly
       end
 
       def create_index_table(table)
+        attr = attr_klass # close around this please
+
         db.create_table(table.table_name) do
-          binary      :id,         :size => 16
-          table.fields.flatten.each do |f|
-            method(table.klass.attributes[f].type.name.to_sym).call(f)
+          binary :id, :size => 16
+          table.fields.flatten.each do |f|    
+            klass = table.klass.attributes[f].type
+            type  = attr.custom_type?(klass) ? attr.sql_type(klass) : klass
+            column(f, type)
           end
           primary_key table.fields.flatten + [:id]
           unique :id

data/lib/friendly/uuid.rb

@@ -1,4 +1,6 @@
 require 'friendly/time'
+require 'friendly/attribute'
+
 # This class was extracted from the cassandra gem by Evan Weaver
 # As such, it is distributed under the terms of the apache license.
 # See the APACHE-LICENSE file in the root of this project for more information.
@@ -141,3 +143,6 @@ module Friendly
   end
 end
 
+Friendly::Attribute.register_type(Friendly::UUID, 'binary(16)') do |s|
+  Friendly::UUID.new(s)
+end

data/spec/config.yml.example

@@ -0,0 +1,7 @@
+test:
+  :adapter:  "mysql"
+  :host:     "localhost"
+  :user:     "root"
+  :password: "swordfish"
+  :database: "friendly_test"
+

data/spec/integration/ad_hoc_scopes_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Querying with an ad-hoc scope" do
+  before do
+    User.all(:name => "Fred").each { |u| u.destroy }
+    @users = (1..10).map { User.create(:name => "Fred") }
+  end
+
+  it "can return all the objects matching the scope" do
+    User.scope(:name => "Fred").all.should == @users
+  end
+
+  it "can return the first object matching the scope" do
+    User.scope(:name => "Fred").first.should == User.first(:name => "Fred")
+  end
+
+  it "can paginate over the matching objects" do
+    found = User.scope(:name => "Fred").paginate(:per_page! => 5)
+    found.should == User.paginate(:name => "Fred", :per_page! => 5)
+  end
+
+  it "can build an object at scope" do
+    User.scope(:name => "Fred", :limit! => 5).build.name.should == "Fred"
+  end
+
+  it "supports overriding parameters when building" do
+    scope = User.scope(:name => "Fred", :limit! => 5)
+    scope.build(:name => "Joe").name.should == "Joe"
+  end
+
+  it "can create an object at scope" do
+    user = User.scope(:name => "Joe").create
+    user.should_not be_new_record
+    user.name.should == "Joe"
+  end
+
+  it "supports overriding parameters when creating" do
+    user = User.scope(:name => "Joe").create(:name => "Fred")
+    user.should_not be_new_record
+    user.name.should == "Fred"
+  end
+end

data/spec/integration/has_many_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Has many associations" do
+  before do
+    @user      = User.create :name => "Fred"
+    @addresses = (0..2).map { Address.create :user_id => @user.id }
+  end
+
+  it "returns the objects whose foreign keys match the object's id" do
+    found = @user.addresses.all.sort { |a, b| a.id <=> b.id }
+    found.should == @addresses.sort { |a, b| a.id <=> b.id }
+  end
+
+  it "accepts class_name and foreign_key overrides" do
+    found = @user.addresses_override.all.sort { |a, b| a.id <=> b.id }
+    found.should == @addresses.sort { |a, b| a.id <=> b.id }
+  end
+end

data/spec/integration/named_scope_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "named_scope" do
+  describe "calling a single named_scope" do
+    before do
+      User.all(:name => "Quagmire").each { |q| q.destroy }
+      5.times { User.create(:name => "Quagmire") }
+    end
+
+    describe "all" do
+      it "returns all objects matching the conditions" do
+        User.named_quagmire.all.should == User.all(:name => "Quagmire")
+      end
+
+      it "accepts extra conditions" do
+        User.create(:name => "Fred")
+        found = User.named_quagmire.all(:name => "Fred")
+        found.should == User.all(:name => "Fred")
+      end
+    end
+
+    describe "first" do
+      it "returns the first object matching the conditions" do
+        User.named_quagmire.first.should == User.first(:name => "Quagmire")
+      end
+
+      it "accepts extra conditions" do
+        User.create(:name => "Fred")
+        found = User.named_quagmire.first(:name => "Fred")
+        found.should == User.first(:name => "Fred")
+      end
+    end
+  end
+end